home *** CD-ROM | disk | FTP | other *** search
/ Aminet 32 / Aminet 32 (1999)(Schatztruhe)[!][Aug 1999].iso / Aminet / dev / lang / Python151_Src.lha / Python1.5_Source / Modules / cPickle.c < prev    next >
C/C++ Source or Header  |  1998-05-27  |  99KB  |  4,349 lines
  1. /*
  2.      cPickle.c,v 1.48 1997/12/07 14:37:39 jim Exp
  3.  
  4.      Copyright 
  5.  
  6.        Copyright 1996 Digital Creations, L.C., 910 Princess Anne
  7.        Street, Suite 300, Fredericksburg, Virginia 22401 U.S.A. All
  8.        rights reserved.  Copyright in this software is owned by DCLC,
  9.        unless otherwise indicated. Permission to use, copy and
  10.        distribute this software is hereby granted, provided that the
  11.        above copyright notice appear in all copies and that both that
  12.        copyright notice and this permission notice appear. Note that
  13.        any product, process or technology described in this software
  14.        may be the subject of other Intellectual Property rights
  15.        reserved by Digital Creations, L.C. and are not licensed
  16.        hereunder.
  17.  
  18.      Trademarks 
  19.  
  20.        Digital Creations & DCLC, are trademarks of Digital Creations, L.C..
  21.        All other trademarks are owned by their respective companies. 
  22.  
  23.      No Warranty 
  24.  
  25.        The software is provided "as is" without warranty of any kind,
  26.        either express or implied, including, but not limited to, the
  27.        implied warranties of merchantability, fitness for a particular
  28.        purpose, or non-infringement. This software could include
  29.        technical inaccuracies or typographical errors. Changes are
  30.        periodically made to the software; these changes will be
  31.        incorporated in new editions of the software. DCLC may make
  32.        improvements and/or changes in this software at any time
  33.        without notice.
  34.  
  35.      Limitation Of Liability 
  36.  
  37.        In no event will DCLC be liable for direct, indirect, special,
  38.        incidental, economic, cover, or consequential damages arising
  39.        out of the use of or inability to use this software even if
  40.        advised of the possibility of such damages. Some states do not
  41.        allow the exclusion or limitation of implied warranties or
  42.        limitation of liability for incidental or consequential
  43.        damages, so the above limitation or exclusion may not apply to
  44.        you.
  45.  
  46.     If you have questions regarding this software,
  47.     contact:
  48.    
  49.       Jim Fulton, jim@digicool.com
  50.       Digital Creations L.C.  
  51.    
  52.       (540) 371-6909
  53. */
  54.  
  55. static char cPickle_module_documentation[] = 
  56. "C implementation and optimization of the Python pickle module\n"
  57. "\n"
  58. "cPickle.c,v 1.48 1997/12/07 14:37:39 jim Exp\n"
  59. ;
  60.  
  61. #include "Python.h"
  62. #include "cStringIO.h"
  63. #include "mymath.h"
  64.  
  65. #ifndef Py_eval_input
  66. #include <graminit.h>
  67. #define Py_eval_input eval_input
  68. #endif /* Py_eval_input */
  69.  
  70. #include <errno.h>
  71.  
  72. #ifdef _AMIGA
  73. #ifdef GLOBAL
  74. #undef GLOBAL
  75. #endif
  76. #endif
  77.  
  78. #define UNLESS(E) if (!(E))
  79.  
  80. #define DEL_LIST_SLICE(list, from, to) (PyList_SetSlice(list, from, to, NULL))
  81.  
  82. #define WRITE_BUF_SIZE 256
  83.  
  84.  
  85. #define MARK        '('
  86. #define STOP        '.'
  87. #define POP         '0'
  88. #define POP_MARK    '1'
  89. #define DUP         '2'
  90. #define FLOAT       'F'
  91. #define BINFLOAT    'G'
  92. #define INT         'I'
  93. #define BININT      'J'
  94. #define BININT1     'K'
  95. #define LONG        'L'
  96. #define BININT2     'M'
  97. #define NONE        'N'
  98. #define PERSID      'P'
  99. #define BINPERSID   'Q'
  100. #define REDUCE      'R'
  101. #define STRING      'S'
  102. #define BINSTRING   'T'
  103. #define SHORT_BINSTRING 'U'
  104. #define APPEND      'a'
  105. #define BUILD       'b'
  106. #define GLOBAL      'c'
  107. #define DICT        'd'
  108. #define EMPTY_DICT  '}'
  109. #define APPENDS     'e'
  110. #define GET         'g'
  111. #define BINGET      'h'
  112. #define INST        'i'
  113. #define LONG_BINGET 'j'
  114. #define LIST        'l'
  115. #define EMPTY_LIST  ']'
  116. #define OBJ         'o'
  117. #define PUT         'p'
  118. #define BINPUT      'q'
  119. #define LONG_BINPUT 'r'
  120. #define SETITEM     's'
  121. #define TUPLE       't'
  122. #define EMPTY_TUPLE ')'
  123. #define SETITEMS    'u'
  124.  
  125. static char MARKv = MARK;
  126.  
  127. /* atol function from string module */
  128. static PyObject *atol_func;
  129.  
  130. static PyObject *PicklingError;
  131. static PyObject *UnpicklingError;
  132.  
  133. static PyObject *dispatch_table;
  134. static PyObject *safe_constructors;
  135. static PyObject *class_map;
  136. static PyObject *empty_tuple;
  137.  
  138. static PyObject *__class___str, *__getinitargs___str, *__dict___str,
  139.   *__getstate___str, *__setstate___str, *__name___str, *__reduce___str,
  140.   *write_str, *__safe_for_unpickling___str, *append_str,
  141.   *read_str, *readline_str, *__main___str, *__basicnew___str,
  142.   *copy_reg_str, *dispatch_table_str, *safe_constructors_str;
  143.  
  144. typedef struct _Picklerobject_struct {
  145.      PyObject_HEAD
  146.      FILE *fp;
  147.      PyObject *write;
  148.      PyObject *file;
  149.      PyObject *memo;
  150.      PyObject *arg;
  151.      PyObject *pers_func;
  152.      PyObject *inst_pers_func;
  153.      int bin;
  154.      int (*write_func)Py_PROTO((struct _Picklerobject_struct *self, char *s, int n));
  155.      char *write_buf;
  156.      int buf_size;
  157.      PyObject *dispatch_table;
  158.      PyObject *class_map;
  159. } Picklerobject;
  160.  
  161. static int save Py_PROTO((Picklerobject *self, PyObject *args, int  pers_save));
  162. static int put2 Py_PROTO((Picklerobject *self, PyObject *ob));
  163.  
  164. staticforward PyTypeObject Picklertype;
  165.  
  166. typedef struct _Unpicklerobject_struct {
  167.      PyObject_HEAD
  168.      FILE *fp;
  169.      PyObject *file;
  170.      PyObject *readline;
  171.      PyObject *read;
  172.      PyObject *memo;
  173.      PyObject *arg;
  174.      PyObject *stack;
  175.      PyObject *mark;
  176.      PyObject *pers_func;
  177.      PyObject *last_string;
  178.      int *marks;
  179.      int num_marks;
  180.      int marks_size;
  181.      int (*read_func)Py_PROTO((struct _Unpicklerobject_struct *self, char **s, int n));
  182.      int (*readline_func)Py_PROTO((struct _Unpicklerobject_struct *self, char **s));
  183.      int buf_size;
  184.      char *buf;
  185.      PyObject *safe_constructors;
  186.      PyObject *class_map;
  187. } Unpicklerobject;
  188.  
  189. staticforward PyTypeObject Unpicklertype;
  190.  
  191. int 
  192. cPickle_PyMapping_HasKey(PyObject *o, PyObject *key) {
  193.     PyObject *v;
  194.  
  195.     if((v = PyObject_GetItem(o,key))) {
  196.         Py_DECREF(v);
  197.         return 1;
  198.     }
  199.  
  200.     PyErr_Clear();
  201.     return 0;
  202. }
  203.  
  204. static
  205. PyObject *
  206. #ifdef HAVE_STDARG_PROTOTYPES
  207. /* VARARGS 2 */
  208. cPickle_ErrFormat(PyObject *ErrType, char *stringformat, char *format, ...) {
  209. #else
  210. /* VARARGS */
  211. cPickle_ErrFormat(va_alist) va_dcl {
  212. #endif
  213.   va_list va;
  214.   PyObject *args=0, *retval=0;
  215. #ifdef HAVE_STDARG_PROTOTYPES
  216.   va_start(va, format);
  217. #else
  218.   PyObject *ErrType;
  219.   char *stringformat, *format;
  220.   va_start(va);
  221.   ErrType = va_arg(va, PyObject *);
  222.   stringformat   = va_arg(va, char *);
  223.   format   = va_arg(va, char *);
  224. #endif
  225.   
  226.   if(format) args = Py_VaBuildValue(format, va);
  227.   va_end(va);
  228.   if(format && ! args) return NULL;
  229.   if(stringformat && !(retval=PyString_FromString(stringformat))) return NULL;
  230.  
  231.   if(retval) {
  232.       if(args) {
  233.       PyObject *v;
  234.       v=PyString_Format(retval, args);
  235.       Py_DECREF(retval);
  236.       Py_DECREF(args);
  237.       if(! v) return NULL;
  238.       retval=v;
  239.     }
  240.     }
  241.   else
  242.     if(args) retval=args;
  243.     else {
  244.     PyErr_SetObject(ErrType,Py_None);
  245.     return NULL;
  246.       }
  247.   PyErr_SetObject(ErrType,retval);
  248.   Py_DECREF(retval);
  249.   return NULL;
  250. }
  251.  
  252. static int 
  253. write_file(Picklerobject *self, char *s, int  n) {
  254.     if (s == NULL) {
  255.         return 0;
  256.     }
  257.  
  258.     if ((int)fwrite(s, sizeof(char), n, self->fp) != n) {
  259.         PyErr_SetFromErrno(PyExc_IOError);
  260.         return -1;
  261.     }
  262.  
  263.     return n;
  264. }
  265.  
  266.  
  267. static int 
  268. write_cStringIO(Picklerobject *self, char *s, int  n) {
  269.     if (s == NULL) {
  270.         return 0;
  271.     }
  272.  
  273.     if (PycStringIO->cwrite((PyObject *)self->file, s, n) != n) {
  274.         return -1;
  275.     }
  276.  
  277.     return n;
  278. }
  279.  
  280.  
  281. static int 
  282. write_none(Picklerobject *self, char *s, int  n) {
  283.     if (s == NULL) return 0;
  284.     return n;
  285. }
  286.  
  287.  
  288. static int 
  289. write_other(Picklerobject *self, char *s, int  n) {
  290.     PyObject *py_str = 0, *junk = 0;
  291.     int res = -1;
  292.  
  293.     if (s == NULL) {
  294.         UNLESS(self->buf_size) return 0;
  295.         UNLESS(py_str = 
  296.             PyString_FromStringAndSize(self->write_buf, self->buf_size))
  297.             goto finally;
  298.     }
  299.     else {
  300.         if (self->buf_size && (n + self->buf_size) > WRITE_BUF_SIZE) {
  301.             if (write_other(self, NULL, 0) < 0)
  302.                 goto finally;
  303.         }
  304.  
  305.         if (n > WRITE_BUF_SIZE) {    
  306.             UNLESS(py_str = 
  307.                 PyString_FromStringAndSize(s, n))
  308.                 goto finally;
  309.         }
  310.         else {
  311.             memcpy(self->write_buf + self->buf_size, s, n);
  312.             self->buf_size += n;
  313.             res = n;
  314.             goto finally;
  315.         }
  316.     }
  317.  
  318.     UNLESS(self->arg)
  319.         UNLESS(self->arg = PyTuple_New(1))
  320.             goto finally;
  321.  
  322.     Py_INCREF(py_str);
  323.     if (PyTuple_SetItem(self->arg, 0, py_str) < 0)
  324.         goto finally;
  325.  
  326.     UNLESS(junk = PyObject_CallObject(self->write, self->arg))
  327.         goto finally;
  328.     Py_DECREF(junk);
  329.  
  330.     self->buf_size = 0;
  331.  
  332.     res = n;
  333.  
  334. finally:
  335.     Py_XDECREF(py_str);
  336.  
  337.     return res;
  338. }
  339.  
  340.  
  341. static int 
  342. read_file(Unpicklerobject *self, char **s, int  n) {
  343.  
  344.     if (self->buf_size == 0) {
  345.         int size;
  346.  
  347.         size = ((n < 32) ? 32 : n); 
  348.         UNLESS(self->buf = (char *)malloc(size * sizeof(char))) {
  349.             PyErr_NoMemory();
  350.             return -1;
  351.         }
  352.  
  353.         self->buf_size = size;
  354.     }
  355.     else if (n > self->buf_size) {
  356.         UNLESS(self->buf = (char *)realloc(self->buf, n * sizeof(char))) {
  357.             PyErr_NoMemory();
  358.             return -1;
  359.         }
  360.  
  361.         self->buf_size = n;
  362.     }
  363.             
  364.     if ((int)fread(self->buf, sizeof(char), n, self->fp) != n) {  
  365.         if (feof(self->fp)) {
  366.             PyErr_SetNone(PyExc_EOFError);
  367.             return -1;
  368.         }
  369.  
  370.         PyErr_SetFromErrno(PyExc_IOError);
  371.         return -1;
  372.     }
  373.  
  374.     *s = self->buf;
  375.  
  376.     return n;
  377. }
  378.  
  379.  
  380. static int 
  381. readline_file(Unpicklerobject *self, char **s) {
  382.     int i;
  383.  
  384.     if (self->buf_size == 0) {
  385.         UNLESS(self->buf = (char *)malloc(40 * sizeof(char))) {
  386.             PyErr_NoMemory();
  387.             return -1;
  388.         }
  389.    
  390.         self->buf_size = 40;
  391.     }
  392.  
  393.     i = 0;
  394.     while (1) {
  395.         for (; i < (self->buf_size - 1); i++) {
  396.             if (feof(self->fp) || (self->buf[i] = getc(self->fp)) == '\n') {
  397.                 self->buf[i + 1] = '\0';
  398.                 *s = self->buf;
  399.                 return i + 1;
  400.             }
  401.         }
  402.  
  403.         UNLESS(self->buf = (char *)realloc(self->buf, 
  404.             (self->buf_size * 2) * sizeof(char))) {
  405.             PyErr_NoMemory();
  406.             return -1;
  407.         }
  408.  
  409.         self->buf_size *= 2;
  410.     }
  411.  
  412. }    
  413.  
  414.  
  415. static int 
  416. read_cStringIO(Unpicklerobject *self, char **s, int  n) {
  417.     char *ptr;
  418.  
  419.     if (PycStringIO->cread((PyObject *)self->file, &ptr, n) != n) {
  420.         PyErr_SetNone(PyExc_EOFError);
  421.         return -1;
  422.     }
  423.  
  424.     *s = ptr;
  425.  
  426.     return n;
  427. }
  428.  
  429.  
  430. static int 
  431. readline_cStringIO(Unpicklerobject *self, char **s) {
  432.     int n;
  433.     char *ptr;
  434.  
  435.     if ((n = PycStringIO->creadline((PyObject *)self->file, &ptr)) < 0) {
  436.         return -1;
  437.     }
  438.  
  439.     *s = ptr;
  440.  
  441.     return n;
  442. }
  443.  
  444.  
  445. static int 
  446. read_other(Unpicklerobject *self, char **s, int  n) {
  447.     PyObject *bytes, *str;
  448.     int res = -1;
  449.  
  450.     UNLESS(bytes = PyInt_FromLong(n)) {
  451.         if (!PyErr_Occurred())
  452.             PyErr_SetNone(PyExc_EOFError);
  453.  
  454.         goto finally;
  455.     }
  456.  
  457.     UNLESS(self->arg)
  458.         UNLESS(self->arg = PyTuple_New(1))
  459.             goto finally;
  460.  
  461.     Py_INCREF(bytes);
  462.     if (PyTuple_SetItem(self->arg, 0, bytes) < 0)
  463.         goto finally;
  464.  
  465.     UNLESS(str = PyObject_CallObject(self->read, self->arg))
  466.         goto finally;
  467.  
  468.     Py_XDECREF(self->last_string);
  469.     self->last_string = str;
  470.  
  471.     *s = PyString_AsString(str);
  472.  
  473.     res = n;
  474.  
  475. finally:
  476.      Py_XDECREF(bytes);
  477.  
  478.      return res;
  479. }
  480.  
  481.  
  482. static int 
  483. readline_other(Unpicklerobject *self, char **s) {
  484.     PyObject *str;
  485.     int str_size;
  486.  
  487.     UNLESS(str = PyObject_CallObject(self->readline, empty_tuple)) {
  488.         return -1;
  489.     }
  490.  
  491.     str_size = PyString_Size(str);
  492.  
  493.     Py_XDECREF(self->last_string);
  494.     self->last_string = str;
  495.  
  496.     *s = PyString_AsString(str);
  497.  
  498.     return str_size;
  499. }
  500.  
  501.  
  502. static char *
  503. pystrndup(char *s, int l) {
  504.   char *r;
  505.   UNLESS(r=malloc((l+1)*sizeof(char))) return (char*)PyErr_NoMemory();
  506.   memcpy(r,s,l);
  507.   r[l]=0;
  508.   return r;
  509. }
  510.  
  511.  
  512. static int
  513. get(Picklerobject *self, PyObject *id) {
  514.     PyObject *value = 0;
  515.     long c_value;
  516.     char s[30];
  517.     int len;
  518.  
  519.     UNLESS(value = PyDict_GetItem(self->memo, id))
  520.         return -1;
  521.  
  522.     UNLESS(value = PyTuple_GetItem(value, 0))
  523.         return -1;
  524.         
  525.     c_value = PyInt_AsLong(value);
  526.  
  527.     if (!self->bin) {
  528.         s[0] = GET;
  529.         sprintf(s + 1, "%ld\n", c_value);
  530.         len = strlen(s);
  531.     }
  532.     else {
  533.         if (c_value < 256) {
  534.             s[0] = BINGET;
  535.             s[1] = (int)(c_value & 0xff);
  536.             len = 2;
  537.         }
  538.         else {
  539.             s[0] = LONG_BINGET;
  540.             s[1] = (int)(c_value & 0xff);
  541.             s[2] = (int)((c_value >> 8)  & 0xff);
  542.             s[3] = (int)((c_value >> 16) & 0xff);
  543.             s[4] = (int)((c_value >> 24) & 0xff);
  544.             len = 5;
  545.         }
  546.     }
  547.  
  548.     if ((*self->write_func)(self, s, len) < 0)
  549.         return -1;
  550.  
  551.     return 0;
  552. }
  553.     
  554.  
  555. static int
  556. put(Picklerobject *self, PyObject *ob) {
  557.     if (ob->ob_refcnt < 2)
  558.         return 0;
  559.  
  560.     return put2(self, ob);
  561. }
  562.  
  563.   
  564. static int
  565. put2(Picklerobject *self, PyObject *ob) {
  566.     char c_str[30];
  567.     int p, len, res = -1;
  568.     PyObject *py_ob_id = 0, *memo_len = 0, *t = 0;
  569.     if ((p = PyDict_Size(self->memo)) < 0)
  570.         goto finally;
  571.  
  572.     if (!self->bin) {
  573.         c_str[0] = PUT;
  574.         sprintf(c_str + 1, "%d\n", p);
  575.         len = strlen(c_str);
  576.     }
  577.     else {
  578.         if (p >= 256) {
  579.             c_str[0] = LONG_BINPUT;
  580.             c_str[1] = (int)(p & 0xff);
  581.             c_str[2] = (int)((p >> 8)  & 0xff);
  582.             c_str[3] = (int)((p >> 16) & 0xff);
  583.             c_str[4] = (int)((p >> 24) & 0xff);
  584.             len = 5;
  585.         }
  586.         else {
  587.             c_str[0] = BINPUT;
  588.             c_str[1] = p;
  589.             len = 2; 
  590.         }
  591.     }
  592.  
  593.     if ((*self->write_func)(self, c_str, len) < 0)
  594.         goto finally;
  595.  
  596.     UNLESS(py_ob_id = PyInt_FromLong((long)ob))
  597.         goto finally;
  598.  
  599.     UNLESS(memo_len = PyInt_FromLong(p))
  600.         goto finally;
  601.  
  602.     UNLESS(t = PyTuple_New(2))
  603.         goto finally;
  604.  
  605.     PyTuple_SET_ITEM(t, 0, memo_len);
  606.     Py_INCREF(memo_len);
  607.     PyTuple_SET_ITEM(t, 1, ob);
  608.     Py_INCREF(ob);
  609.  
  610.     if (PyDict_SetItem(self->memo, py_ob_id, t) < 0)
  611.         goto finally;
  612.  
  613.     res = 0;
  614.  
  615. finally:
  616.     Py_XDECREF(py_ob_id);
  617.     Py_XDECREF(memo_len);
  618.     Py_XDECREF(t);
  619.  
  620.     return res;
  621. }
  622.  
  623. #define PyImport_Import cPickle_Import
  624.  
  625. static PyObject *
  626. PyImport_Import(PyObject *module_name) {
  627.   static PyObject *silly_list=0, *__builtins___str=0, *__import___str;
  628.   static PyObject *standard_builtins=0;
  629.   PyObject *globals=0, *__import__=0, *__builtins__=0, *r=0;
  630.  
  631.   UNLESS(silly_list) {
  632.       UNLESS(__import___str=PyString_FromString("__import__")) return NULL;
  633.       UNLESS(__builtins___str=PyString_FromString("__builtins__")) return NULL;
  634.       UNLESS(silly_list=Py_BuildValue("[s]","__doc__")) return NULL;
  635.     }
  636.  
  637.   if((globals=PyEval_GetGlobals())) {
  638.       Py_INCREF(globals);
  639.       UNLESS(__builtins__=PyObject_GetItem(globals,__builtins___str)) goto err;
  640.     }
  641.   else {
  642.       PyErr_Clear();
  643.  
  644.       UNLESS(standard_builtins ||
  645.          (standard_builtins=PyImport_ImportModule("__builtin__")))
  646.     return NULL;
  647.       
  648.       __builtins__=standard_builtins;
  649.       Py_INCREF(__builtins__);
  650.       UNLESS(globals = Py_BuildValue("{sO}", "__builtins__", __builtins__))
  651.     goto err;
  652.     }
  653.  
  654.   if(PyDict_Check(__builtins__)) {
  655.     UNLESS(__import__=PyObject_GetItem(__builtins__,__import___str)) goto err;
  656.   }
  657.   else {
  658.     UNLESS(__import__=PyObject_GetAttr(__builtins__,__import___str)) goto err;
  659.   }
  660.  
  661.   UNLESS(r=PyObject_CallFunction(__import__,"OOOO",
  662.                  module_name, globals, globals, silly_list))
  663.     goto err;
  664.  
  665.   Py_DECREF(globals);
  666.   Py_DECREF(__builtins__);
  667.   Py_DECREF(__import__);
  668.   
  669.   return r;
  670. err:
  671.   Py_XDECREF(globals);
  672.   Py_XDECREF(__builtins__);
  673.   Py_XDECREF(__import__);
  674.   return NULL;
  675. }
  676.  
  677. static PyObject *
  678. whichmodule(PyObject *class_map, PyObject *global, PyObject *global_name) {
  679.     int i, j;
  680.     PyObject *module = 0, *modules_dict = 0,
  681.         *global_name_attr = 0, *name = 0;
  682.  
  683.     module = PyObject_GetAttrString(global, "__module__");
  684.     if (module) return module;
  685.     PyErr_Clear();
  686.  
  687.     if ((module = PyDict_GetItem(class_map, global))) {
  688.         Py_INCREF(module);
  689.         return module;
  690.     }
  691.     else {
  692.         PyErr_Clear();
  693.     }
  694.  
  695.     UNLESS(modules_dict = PySys_GetObject("modules"))
  696.         return NULL;
  697.  
  698.     i = 0;
  699.     while ((j = PyDict_Next(modules_dict, &i, &name, &module))) {
  700.  
  701.         if(PyObject_Compare(name, __main___str)==0) continue;
  702.       
  703.         UNLESS(global_name_attr = PyObject_GetAttr(module, global_name)) {
  704.             PyErr_Clear();
  705.             continue;
  706.         }
  707.  
  708.         if (global_name_attr != global) {
  709.             Py_DECREF(global_name_attr);
  710.             continue;
  711.         }
  712.  
  713.         Py_DECREF(global_name_attr);
  714.  
  715.         break;
  716.     }
  717.  
  718.     /* The following implements the rule in pickle.py added in 1.5
  719.        that used __main__ if no module is found.  I don't actually
  720.        like this rule. jlf
  721.      */
  722.     if(!j) {
  723.         j=1;
  724.         name=__main___str;
  725.     }
  726.     
  727.     /*
  728.     if (!j) {
  729.         cPickle_ErrFormat(PicklingError, "Could not find module for %s.", 
  730.             "O", global_name);
  731.         return NULL;
  732.     }
  733.     */
  734.  
  735.     PyDict_SetItem(class_map, global, name);
  736.  
  737.     Py_INCREF(name);
  738.     return name;
  739. }
  740.  
  741.  
  742. static int
  743. save_none(Picklerobject *self, PyObject *args) {
  744.     static char none = NONE;
  745.     if ((*self->write_func)(self, &none, 1) < 0)  
  746.         return -1;
  747.  
  748.     return 0;
  749. }
  750.  
  751.       
  752. static int
  753. save_int(Picklerobject *self, PyObject *args) {
  754.     char c_str[32];
  755.     long l = PyInt_AS_LONG((PyIntObject *)args);
  756.     int len = 0;
  757.  
  758.     if (!self->bin
  759. #if SIZEOF_LONG > 4
  760.     || (l >> 32)
  761. #endif
  762.         ) {
  763.             /* Save extra-long ints in non-binary mode, so that
  764.            we can use python long parsing code to restore,
  765.            if necessary. */
  766.         c_str[0] = INT;
  767.         sprintf(c_str + 1, "%ld\n", l);
  768.         if ((*self->write_func)(self, c_str, strlen(c_str)) < 0)
  769.             return -1;
  770.     }
  771.     else {
  772.         c_str[1] = (int)( l        & 0xff);
  773.         c_str[2] = (int)((l >> 8)  & 0xff);
  774.         c_str[3] = (int)((l >> 16) & 0xff);
  775.         c_str[4] = (int)((l >> 24) & 0xff);
  776.  
  777.         if ((c_str[4] == 0) && (c_str[3] == 0)) {
  778.             if (c_str[2] == 0) {
  779.                 c_str[0] = BININT1;
  780.                 len = 2;
  781.             }
  782.             else {
  783.                 c_str[0] = BININT2;
  784.                 len = 3;
  785.             }
  786.         }
  787.         else {
  788.             c_str[0] = BININT;
  789.             len = 5;
  790.         }
  791.  
  792.         if ((*self->write_func)(self, c_str, len) < 0)
  793.             return -1;
  794.     }
  795.  
  796.     return 0;
  797. }
  798.  
  799.  
  800. static int
  801. save_long(Picklerobject *self, PyObject *args) {
  802.     int size, res = -1;
  803.     PyObject *repr = 0;
  804.  
  805.     static char l = LONG;
  806.  
  807.     UNLESS(repr = PyObject_Repr(args))
  808.         goto finally;
  809.  
  810.     if ((size = PyString_Size(repr)) < 0)
  811.         goto finally;
  812.  
  813.     if ((*self->write_func)(self, &l, 1) < 0)
  814.         goto finally;
  815.  
  816.     if ((*self->write_func)(self, 
  817.         PyString_AS_STRING((PyStringObject *)repr), size) < 0)
  818.         goto finally;
  819.  
  820.     if ((*self->write_func)(self, "\n", 1) < 0)
  821.         goto finally;
  822.  
  823.     res = 0;
  824.  
  825. finally:
  826.     Py_XDECREF(repr);
  827.  
  828.     return res;
  829. }
  830.  
  831.  
  832. static int
  833. save_float(Picklerobject *self, PyObject *args) {
  834.     double x = PyFloat_AS_DOUBLE((PyFloatObject *)args);
  835.  
  836. #ifdef FORMAT_1_3
  837.     if (self->bin) {
  838.         int s, e;
  839.         double f;
  840.         long fhi, flo;
  841.         char str[9], *p = str;
  842.  
  843.         *p = BINFLOAT;
  844.         p++;
  845.  
  846.         if (x < 0) {
  847.             s = 1;
  848.             x = -x;
  849.         }
  850.         else
  851.             s = 0;
  852.  
  853.         f = frexp(x, &e);
  854.  
  855.         /* Normalize f to be in the range [1.0, 2.0) */
  856.         if (0.5 <= f && f < 1.0) {
  857.             f *= 2.0;
  858.             e--;
  859.         }
  860.         else if (f == 0.0) {
  861.             e = 0;
  862.         }
  863.         else {
  864.             PyErr_SetString(PyExc_SystemError,
  865.                             "frexp() result out of range");
  866.             return -1;
  867.         }
  868.  
  869.         if (e >= 1024) {
  870.             /* XXX 1024 itself is reserved for Inf/NaN */
  871.             PyErr_SetString(PyExc_OverflowError,
  872.                             "float too large to pack with d format");
  873.             return -1;
  874.         }
  875.         else if (e < -1022) {
  876.             /* Gradual underflow */
  877.             f = ldexp(f, 1022 + e);
  878.             e = 0;
  879.         }
  880.         else {
  881.             e += 1023;
  882.             f -= 1.0; /* Get rid of leading 1 */
  883.         }
  884.  
  885.         /* fhi receives the high 28 bits; flo the low 24 bits (== 52 bits) */
  886.         f *= 268435456.0; /* 2**28 */
  887.         fhi = (long) floor(f); /* Truncate */
  888.         f -= (double)fhi;
  889.         f *= 16777216.0; /* 2**24 */
  890.         flo = (long) floor(f + 0.5); /* Round */
  891.  
  892.         /* First byte */
  893.         *p = (s<<7) | (e>>4);
  894.         p++;
  895.  
  896.         /* Second byte */
  897.         *p = ((e&0xF)<<4) | (fhi>>24);
  898.         p++;
  899.  
  900.         /* Third byte */
  901.         *p = (fhi>>16) & 0xFF;
  902.         p++;
  903.  
  904.         /* Fourth byte */
  905.         *p = (fhi>>8) & 0xFF;
  906.         p++;
  907.  
  908.         /* Fifth byte */
  909.         *p = fhi & 0xFF;
  910.         p++;
  911.  
  912.         /* Sixth byte */
  913.         *p = (flo>>16) & 0xFF;
  914.         p++;
  915.  
  916.         /* Seventh byte */
  917.         *p = (flo>>8) & 0xFF;
  918.         p++;
  919.  
  920.         /* Eighth byte */
  921.         *p = flo & 0xFF;
  922.  
  923.         if ((*self->write_func)(self, str, 9) < 0)
  924.             return -1;
  925.     }
  926.     else
  927. #endif
  928.     {
  929.         char c_str[250];
  930.         c_str[0] = FLOAT;
  931.         sprintf(c_str + 1, "%.17g\n", x);
  932.  
  933.         if ((*self->write_func)(self, c_str, strlen(c_str)) < 0)
  934.             return -1;
  935.     }
  936.  
  937.     return 0;
  938. }
  939.  
  940.  
  941. static int
  942. save_string(Picklerobject *self, PyObject *args, int doput) {
  943.     int size, len;
  944.  
  945.     size = PyString_Size(args);
  946.  
  947.     if (!self->bin) {
  948.         PyObject *repr;
  949.         char *repr_str;
  950.  
  951.         static char string = STRING;
  952.  
  953.         UNLESS(repr = PyObject_Repr(args))
  954.             return -1;
  955.  
  956.         repr_str = PyString_AS_STRING((PyStringObject *)repr);
  957.         len = PyString_Size(repr);
  958.  
  959.         if ((*self->write_func)(self, &string, 1) < 0)
  960.             return -1;
  961.  
  962.         if ((*self->write_func)(self, repr_str, len) < 0)
  963.             return -1;
  964.  
  965.         if ((*self->write_func)(self, "\n", 1) < 0)
  966.             return -1;
  967.  
  968.         Py_XDECREF(repr);
  969.     }
  970.     else {
  971.         int i;
  972.         char c_str[5];
  973.  
  974.         size = PyString_Size(args);
  975.  
  976.         if (size < 256) {
  977.             c_str[0] = SHORT_BINSTRING;
  978.             c_str[1] = size;
  979.             len = 2;
  980.         }
  981.         else {
  982.             c_str[0] = BINSTRING;
  983.             for (i = 1; i < 5; i++)
  984.                 c_str[i] = (int)(size >> ((i - 1) * 8));
  985.             len = 5;
  986.         }
  987.  
  988.         if ((*self->write_func)(self, c_str, len) < 0)
  989.             return -1;
  990.  
  991.         if ((*self->write_func)(self, 
  992.             PyString_AS_STRING((PyStringObject *)args), size) < 0)
  993.             return -1;
  994.     }
  995.  
  996.     if (doput)
  997.       if (put(self, args) < 0)
  998.     return -1;
  999.  
  1000.     return 0;
  1001. }
  1002.  
  1003.  
  1004. static int
  1005. save_tuple(Picklerobject *self, PyObject *args) {
  1006.     PyObject *element = 0, *py_tuple_id = 0;
  1007.     int len, i, has_key, res = -1;
  1008.  
  1009.     static char tuple = TUPLE;
  1010.  
  1011.     if ((*self->write_func)(self, &MARKv, 1) < 0)
  1012.         goto finally;
  1013.  
  1014.     if ((len = PyTuple_Size(args)) < 0)  
  1015.         goto finally;
  1016.  
  1017.     for (i = 0; i < len; i++) {
  1018.         UNLESS(element = PyTuple_GET_ITEM((PyTupleObject *)args, i))  
  1019.             goto finally;
  1020.     
  1021.         if (save(self, element, 0) < 0)
  1022.             goto finally;
  1023.     }
  1024.  
  1025.     UNLESS(py_tuple_id = PyInt_FromLong((long)args))
  1026.         goto finally;
  1027.  
  1028.     if (len) {
  1029.         if ((has_key = cPickle_PyMapping_HasKey(self->memo, py_tuple_id)) < 0)
  1030.             goto finally;
  1031.  
  1032.         if (has_key) {
  1033.             if (self->bin) {
  1034.                 static char pop_mark = POP_MARK;
  1035.   
  1036.                 if ((*self->write_func)(self, &pop_mark, 1) < 0)
  1037.                     goto finally;
  1038.             }
  1039.             else {
  1040.                 static char pop = POP;
  1041.        
  1042.                 for (i = 0; i <= len; i++) {
  1043.                     if ((*self->write_func)(self, &pop, 1) < 0)
  1044.                         goto finally;
  1045.                 } 
  1046.             }
  1047.         
  1048.             if (get(self, py_tuple_id) < 0)
  1049.                 goto finally;
  1050.  
  1051.             res = 0;
  1052.             goto finally;
  1053.         }
  1054.     }
  1055.  
  1056.     if ((*self->write_func)(self, &tuple, 1) < 0) {
  1057.         goto finally;
  1058.     }
  1059.  
  1060.     if (put(self, args) < 0)
  1061.         goto finally;
  1062.  
  1063.     res = 0;
  1064.  
  1065. finally:
  1066.     Py_XDECREF(py_tuple_id);
  1067.  
  1068.     return res;
  1069. }
  1070.  
  1071. static int
  1072. save_empty_tuple(Picklerobject *self, PyObject *args) {
  1073.     static char tuple = EMPTY_TUPLE;
  1074.  
  1075.     return (*self->write_func)(self, &tuple, 1);
  1076. }
  1077.  
  1078.  
  1079. static int
  1080. save_list(Picklerobject *self, PyObject *args) {
  1081.     PyObject *element = 0;
  1082.     int s_len, len, i, using_appends, res = -1;
  1083.     char s[3];
  1084.  
  1085.     static char append = APPEND, appends = APPENDS;
  1086.  
  1087.     if(self->bin) {
  1088.         s[0] = EMPTY_LIST;
  1089.         s_len = 1;
  1090.     } 
  1091.     else {
  1092.         s[0] = MARK;
  1093.         s[1] = LIST;
  1094.         s_len = 2;
  1095.     }
  1096.  
  1097.     if ((len = PyList_Size(args)) < 0)
  1098.         goto finally;
  1099.  
  1100.     if ((*self->write_func)(self, s, s_len) < 0)
  1101.         goto finally;
  1102.  
  1103.     if (len == 0) {
  1104.         if (put(self, args) < 0)
  1105.             goto finally;
  1106.     }
  1107.     else {
  1108.         if (put2(self, args) < 0)
  1109.             goto finally;
  1110.     }
  1111.  
  1112.     if ((using_appends = (self->bin && (len > 1))))
  1113.         if ((*self->write_func)(self, &MARKv, 1) < 0)
  1114.             goto finally;
  1115.  
  1116.     for (i = 0; i < len; i++) {
  1117.         UNLESS(element = PyList_GET_ITEM((PyListObject *)args, i))  
  1118.             goto finally;
  1119.  
  1120.         if (save(self, element, 0) < 0)  
  1121.             goto finally;    
  1122.  
  1123.         if (!using_appends) {
  1124.             if ((*self->write_func)(self, &append, 1) < 0)
  1125.                 goto finally;
  1126.         }
  1127.     }
  1128.  
  1129.     if (using_appends) {
  1130.         if ((*self->write_func)(self, &appends, 1) < 0)
  1131.             goto finally;
  1132.     }
  1133.  
  1134.     res = 0;
  1135.  
  1136. finally:
  1137.  
  1138.     return res;
  1139. }
  1140.  
  1141.  
  1142. static int
  1143. save_dict(Picklerobject *self, PyObject *args) {
  1144.     PyObject *key = 0, *value = 0;
  1145.     int i, len, res = -1, using_setitems;
  1146.     char s[3];
  1147.  
  1148.     static char setitem = SETITEM, setitems = SETITEMS;
  1149.  
  1150.     if (self->bin) {
  1151.     s[0] = EMPTY_DICT;
  1152.     len = 1;
  1153.     }
  1154.     else {
  1155.         s[0] = MARK;
  1156.         s[1] = DICT;
  1157.         len = 2;
  1158.     }
  1159.  
  1160.     if ((*self->write_func)(self, s, len) < 0)
  1161.         goto finally;
  1162.  
  1163.     if ((len = PyDict_Size(args)) < 0)
  1164.         goto finally;
  1165.  
  1166.     if (len == 0) {
  1167.         if (put(self, args) < 0)
  1168.             goto finally;
  1169.     }
  1170.     else {
  1171.         if (put2(self, args) < 0)
  1172.             goto finally;
  1173.     }
  1174.  
  1175.     if ((using_setitems = (self->bin && (PyDict_Size(args) > 1))))
  1176.         if ((*self->write_func)(self, &MARKv, 1) < 0)
  1177.             goto finally;
  1178.  
  1179.     i = 0;
  1180.     while (PyDict_Next(args, &i, &key, &value)) {
  1181.         if (save(self, key, 0) < 0)
  1182.             goto finally;
  1183.  
  1184.         if (save(self, value, 0) < 0)
  1185.             goto finally;
  1186.  
  1187.         if (!using_setitems) {
  1188.             if ((*self->write_func)(self, &setitem, 1) < 0)
  1189.                 goto finally;
  1190.         }
  1191.     }
  1192.  
  1193.     if (using_setitems) {
  1194.         if ((*self->write_func)(self, &setitems, 1) < 0)
  1195.             goto finally;
  1196.     }
  1197.  
  1198.     res = 0;
  1199.  
  1200. finally:
  1201.  
  1202.     return res;
  1203. }
  1204.  
  1205.  
  1206. static int  
  1207. save_inst(Picklerobject *self, PyObject *args) {
  1208.     PyObject *class = 0, *module = 0, *name = 0, *state = 0, 
  1209.              *getinitargs_func = 0, *getstate_func = 0, *class_args = 0;
  1210.     char *module_str, *name_str;
  1211.     int module_size, name_size, res = -1;
  1212.  
  1213.     static char inst = INST, obj = OBJ, build = BUILD;
  1214.  
  1215.     if ((*self->write_func)(self, &MARKv, 1) < 0)
  1216.         goto finally;
  1217.  
  1218.     UNLESS(class = PyObject_GetAttr(args, __class___str))
  1219.         goto finally;
  1220.  
  1221.     if (self->bin) {
  1222.         if (save(self, class, 0) < 0)
  1223.             goto finally;
  1224.     }
  1225.  
  1226.     if ((getinitargs_func = PyObject_GetAttr(args, __getinitargs___str))) {
  1227.         PyObject *element = 0;
  1228.         int i, len;
  1229.  
  1230.         UNLESS(class_args = 
  1231.             PyObject_CallObject(getinitargs_func, empty_tuple))
  1232.             goto finally;
  1233.  
  1234.         if ((len = PyObject_Length(class_args)) < 0)  
  1235.             goto finally;
  1236.  
  1237.         for (i = 0; i < len; i++) {
  1238.             UNLESS(element = PySequence_GetItem(class_args, i)) 
  1239.                 goto finally;
  1240.  
  1241.             if (save(self, element, 0) < 0) {
  1242.                 Py_DECREF(element);
  1243.                 goto finally;
  1244.             }
  1245.  
  1246.             Py_DECREF(element);
  1247.         }
  1248.     }
  1249.     else {
  1250.         PyErr_Clear();
  1251.     }
  1252.  
  1253.     if (!self->bin) {
  1254.         UNLESS(name = ((PyClassObject *)class)->cl_name) {
  1255.             PyErr_SetString(PicklingError, "class has no name");
  1256.             goto finally;
  1257.         }
  1258.  
  1259.         UNLESS(module = whichmodule(self->class_map, class, name))
  1260.             goto finally;
  1261.     
  1262.         module_str = PyString_AS_STRING((PyStringObject *)module);
  1263.         module_size = PyString_Size(module);
  1264.         name_str   = PyString_AS_STRING((PyStringObject *)name);
  1265.         name_size = PyString_Size(name);
  1266.  
  1267.         if ((*self->write_func)(self, &inst, 1) < 0)
  1268.             goto finally;
  1269.  
  1270.         if ((*self->write_func)(self, module_str, module_size) < 0)
  1271.             goto finally;
  1272.  
  1273.         if ((*self->write_func)(self, "\n", 1) < 0)
  1274.             goto finally;
  1275.  
  1276.         if ((*self->write_func)(self, name_str, name_size) < 0)
  1277.             goto finally;
  1278.  
  1279.         if ((*self->write_func)(self, "\n", 1) < 0)
  1280.             goto finally;
  1281.     }
  1282.     else if ((*self->write_func)(self, &obj, 1) < 0) {
  1283.         goto finally;
  1284.     }
  1285.  
  1286.     if ((getstate_func = PyObject_GetAttr(args, __getstate___str))) {
  1287.         UNLESS(state = PyObject_CallObject(getstate_func, empty_tuple))
  1288.             goto finally;
  1289.     }
  1290.     else {
  1291.         PyErr_Clear();
  1292.  
  1293.         UNLESS(state = PyObject_GetAttr(args, __dict___str)) {
  1294.             PyErr_Clear();
  1295.             res = 0;
  1296.             goto finally;
  1297.         }
  1298.     }
  1299.  
  1300.     if (!PyDict_Check(state)) {
  1301.         if (put2(self, args) < 0)
  1302.             goto finally;
  1303.     }
  1304.     else {
  1305.         if (put(self, args) < 0)
  1306.             goto finally;
  1307.     }
  1308.   
  1309.     if (save(self, state, 0) < 0)
  1310.         goto finally;
  1311.  
  1312.     if ((*self->write_func)(self, &build, 1) < 0)
  1313.         goto finally;
  1314.  
  1315.     res = 0;
  1316.  
  1317. finally:
  1318.     Py_XDECREF(module);
  1319.     Py_XDECREF(class);
  1320.     Py_XDECREF(state);
  1321.     Py_XDECREF(getinitargs_func);
  1322.     Py_XDECREF(getstate_func);
  1323.     Py_XDECREF(class_args);
  1324.  
  1325.     return res;
  1326. }
  1327.  
  1328.  
  1329. static int
  1330. save_global(Picklerobject *self, PyObject *args, PyObject *name) {
  1331.     PyObject *global_name = 0, *module = 0;
  1332.     char *name_str, *module_str; 
  1333.     int module_size, name_size, res = -1;
  1334.  
  1335.     static char global = GLOBAL;
  1336.  
  1337.     if (name) {
  1338.         global_name = name;
  1339.         Py_INCREF(global_name);
  1340.     }
  1341.     else {
  1342.         UNLESS(global_name = PyObject_GetAttr(args, __name___str))
  1343.             goto finally;
  1344.     }
  1345.  
  1346.     UNLESS(module = whichmodule(self->class_map, args, global_name))
  1347.         goto finally;
  1348.  
  1349.     module_str = PyString_AS_STRING((PyStringObject *)module);
  1350.     module_size = PyString_Size(module);
  1351.     name_str   = PyString_AS_STRING((PyStringObject *)global_name);
  1352.     name_size = PyString_Size(global_name);
  1353.  
  1354.     if ((*self->write_func)(self, &global, 1) < 0)
  1355.         goto finally;
  1356.  
  1357.     if ((*self->write_func)(self, module_str, module_size) < 0)
  1358.         goto finally;
  1359.  
  1360.     if ((*self->write_func)(self, "\n", 1) < 0)
  1361.         goto finally;
  1362.  
  1363.     if ((*self->write_func)(self, name_str, name_size) < 0)
  1364.         goto finally;
  1365.  
  1366.     if ((*self->write_func)(self, "\n", 1) < 0)
  1367.         goto finally;
  1368.  
  1369.     if (put(self, args) < 0)
  1370.         goto finally;
  1371.  
  1372.     res = 0;
  1373.  
  1374. finally:
  1375.     Py_XDECREF(module);
  1376.     Py_XDECREF(global_name);
  1377.  
  1378.     return res;
  1379. }
  1380.  
  1381. static int
  1382. save_pers(Picklerobject *self, PyObject *args, PyObject *f) {
  1383.     PyObject *pid = 0;
  1384.     int size, res = -1;
  1385.  
  1386.     static char persid = PERSID, binpersid = BINPERSID;
  1387.  
  1388.     UNLESS(self->arg)
  1389.         UNLESS(self->arg = PyTuple_New(1))
  1390.             goto finally;
  1391.     
  1392.     Py_INCREF(args);      
  1393.     if (PyTuple_SetItem(self->arg, 0, args) < 0)
  1394.         goto finally;
  1395.     
  1396.     UNLESS(pid = PyObject_CallObject(f, self->arg))
  1397.         goto finally;
  1398.  
  1399.     if (pid != Py_None) {
  1400.         if (!self->bin) {
  1401.             if (!PyString_Check(pid)) {
  1402.                 PyErr_SetString(PicklingError, 
  1403.                     "persistent id must be string");
  1404.                 goto finally;
  1405.             }
  1406.  
  1407.             if ((*self->write_func)(self, &persid, 1) < 0)
  1408.                 goto finally;
  1409.  
  1410.             if ((size = PyString_Size(pid)) < 0)
  1411.                 goto finally;
  1412.  
  1413.             if ((*self->write_func)(self, 
  1414.                 PyString_AS_STRING((PyStringObject *)pid), size) < 0)
  1415.                 goto finally;
  1416.  
  1417.             if ((*self->write_func)(self, "\n", 1) < 0)
  1418.                 goto finally;
  1419.      
  1420.             res = 1;
  1421.             goto finally;
  1422.         }
  1423.         else if (save(self, pid, 1) >= 0) {
  1424.             if ((*self->write_func)(self, &binpersid, 1) < 0)
  1425.                 res = -1;
  1426.             else
  1427.                 res = 1;
  1428.         }
  1429.  
  1430.         goto finally;              
  1431.     }
  1432.  
  1433.     res = 0;
  1434.  
  1435. finally:
  1436.     Py_XDECREF(pid);
  1437.  
  1438.     return res;
  1439. }
  1440.  
  1441.  
  1442. static int 
  1443. save_reduce(Picklerobject *self, PyObject *callable,
  1444.             PyObject *tup, PyObject *state, PyObject *ob) {
  1445.     static char reduce = REDUCE, build = BUILD;
  1446.  
  1447.     if (save(self, callable, 0) < 0)
  1448.         return -1;
  1449.  
  1450.     if (save(self, tup, 0) < 0)
  1451.         return -1;
  1452.  
  1453.     if ((*self->write_func)(self, &reduce, 1) < 0)
  1454.         return -1;
  1455.  
  1456.     if (ob != NULL) {
  1457.         if (state && !PyDict_Check(state)) {
  1458.             if (put2(self, ob) < 0)
  1459.                 return -1;
  1460.         }
  1461.         else {
  1462.             if (put(self, ob) < 0)
  1463.                 return -1;
  1464.         }
  1465.     }
  1466.     
  1467.     if (state) {
  1468.         if (save(self, state, 0) < 0)
  1469.             return -1;
  1470.  
  1471.         if ((*self->write_func)(self, &build, 1) < 0)
  1472.             return -1;
  1473.     }
  1474.  
  1475.     return 0;
  1476. }
  1477.  
  1478. static int
  1479. save(Picklerobject *self, PyObject *args, int  pers_save) {
  1480.     PyTypeObject *type;
  1481.     PyObject *py_ob_id = 0, *__reduce__ = 0, *t = 0, *arg_tup = 0,
  1482.              *callable = 0, *state = 0;
  1483.     int res = -1, tmp, size;
  1484.  
  1485.     if (!pers_save && self->pers_func) {
  1486.         if ((tmp = save_pers(self, args, self->pers_func)) != 0) {
  1487.             res = tmp;
  1488.             goto finally;
  1489.         }
  1490.     }
  1491.  
  1492.     if (args == Py_None) {
  1493.         res = save_none(self, args);
  1494.         goto finally;
  1495.     }
  1496.  
  1497.     type = args->ob_type;
  1498.  
  1499.     switch (type->tp_name[0]) {
  1500.         case 'i':
  1501.             if (type == &PyInt_Type) {
  1502.                 res = save_int(self, args);
  1503.                 goto finally;
  1504.             }
  1505.             break;
  1506.  
  1507.         case 'l':
  1508.             if (type == &PyLong_Type) {
  1509.                 res = save_long(self, args);
  1510.                 goto finally;
  1511.             }
  1512.             break;
  1513.  
  1514.         case 'f':
  1515.             if (type == &PyFloat_Type) {
  1516.                 res = save_float(self, args);
  1517.                 goto finally;
  1518.             }
  1519.         break;
  1520.  
  1521.         case 't':
  1522.             if (type == &PyTuple_Type && PyTuple_Size(args)==0) {
  1523.             if(self->bin) res = save_empty_tuple(self, args);
  1524.             else          res = save_tuple(self, args);
  1525.                 goto finally;
  1526.             }
  1527.  
  1528.         case 's':
  1529.             if ((type == &PyString_Type) && (PyString_Size(args) < 2)) {
  1530.                 res = save_string(self, args, 0);
  1531.                 goto finally;
  1532.             }
  1533.     }
  1534.  
  1535.     if (args->ob_refcnt > 1) {
  1536.         long ob_id;
  1537.         int  has_key;
  1538.  
  1539.         ob_id = (long)args;
  1540.  
  1541.         UNLESS(py_ob_id = PyInt_FromLong(ob_id))
  1542.             goto finally;
  1543.  
  1544.         if ((has_key = cPickle_PyMapping_HasKey(self->memo, py_ob_id)) < 0)
  1545.             goto finally;
  1546.  
  1547.         if (has_key) {
  1548.             if (get(self, py_ob_id) < 0)
  1549.                 goto finally;
  1550.  
  1551.             res = 0;
  1552.             goto finally;
  1553.         }
  1554.     }
  1555.  
  1556.     switch (type->tp_name[0]) {
  1557.         case 's':
  1558.             if (type == &PyString_Type) {
  1559.                 res = save_string(self, args, 1);
  1560.                 goto finally;
  1561.             }
  1562.  
  1563.         case 't':
  1564.             if (type == &PyTuple_Type) {
  1565.                 res = save_tuple(self, args);
  1566.                 goto finally;
  1567.         }
  1568.  
  1569.         case 'l':
  1570.             if (type == &PyList_Type) {
  1571.                 res = save_list(self, args);
  1572.                 goto finally;
  1573.             }
  1574.  
  1575.         case 'd':
  1576.             if (type == &PyDict_Type) {
  1577.                 res = save_dict(self, args);
  1578.                 goto finally; 
  1579.             }
  1580.  
  1581.         case 'i':
  1582.             if (type == &PyInstance_Type) {
  1583.                 res = save_inst(self, args);
  1584.                 goto finally;
  1585.             }
  1586.  
  1587.         case 'c':
  1588.             if (type == &PyClass_Type) {
  1589.                 res = save_global(self, args, NULL);
  1590.                 goto finally;
  1591.             }
  1592.  
  1593.         case 'f':
  1594.             if (type == &PyFunction_Type) {
  1595.                 res = save_global(self, args, NULL);
  1596.                 goto finally;
  1597.             }
  1598.  
  1599.         case 'b':
  1600.             if (type == &PyCFunction_Type) {
  1601.                 res = save_global(self, args, NULL);
  1602.                 goto finally;
  1603.             }
  1604.     }
  1605.  
  1606.     if (!pers_save && self->inst_pers_func) {
  1607.         if ((tmp = save_pers(self, args, self->inst_pers_func)) != 0) {
  1608.             res = tmp;
  1609.             goto finally;
  1610.         }
  1611.     }
  1612.  
  1613.     if ((__reduce__ = PyDict_GetItem(dispatch_table, (PyObject *)type))) {
  1614.         Py_INCREF(__reduce__);
  1615.  
  1616.         UNLESS(self->arg)
  1617.             UNLESS(self->arg = PyTuple_New(1))
  1618.                 goto finally;
  1619.  
  1620.         Py_INCREF(args);
  1621.         if (PyTuple_SetItem(self->arg, 0, args) < 0)
  1622.             goto finally;
  1623.  
  1624.         UNLESS(t = PyObject_CallObject(__reduce__, self->arg))
  1625.             goto finally;
  1626.     }        
  1627.     else {
  1628.         PyErr_Clear();
  1629.  
  1630.         if ((__reduce__ = PyObject_GetAttr(args, __reduce___str))) {
  1631.             UNLESS(t = PyObject_CallObject(__reduce__, empty_tuple))
  1632.                 goto finally;
  1633.         }
  1634.         else {
  1635.             PyErr_Clear();
  1636.         }
  1637.     }
  1638.  
  1639.     if (t) {
  1640.         if (PyString_Check(t)) {
  1641.             res = save_global(self, args, t);
  1642.             goto finally;
  1643.         }
  1644.  
  1645.         if (!PyTuple_Check(t)) {
  1646.             cPickle_ErrFormat(PicklingError, "Value returned by %s must "
  1647.                 "be a tuple", "O", __reduce__);
  1648.             goto finally;
  1649.         }
  1650.  
  1651.         size = PyTuple_Size(t);
  1652.         
  1653.         if ((size != 3) && (size != 2)) {
  1654.             cPickle_ErrFormat(PicklingError, "tuple returned by %s must "     
  1655.                 "contain only two or three elements", "O", __reduce__);
  1656.                 goto finally;
  1657.         }
  1658.         
  1659.         callable = PyTuple_GET_ITEM(t, 0);
  1660.  
  1661.         arg_tup = PyTuple_GET_ITEM(t, 1);
  1662.  
  1663.         if (size > 2) {
  1664.             state = PyTuple_GET_ITEM(t, 2);
  1665.         }
  1666.  
  1667.         UNLESS(PyTuple_Check(arg_tup) || arg_tup==Py_None) {
  1668.             cPickle_ErrFormat(PicklingError, "Second element of tuple "
  1669.                 "returned by %s must be a tuple", "O", __reduce__);
  1670.             goto finally;
  1671.         }
  1672.  
  1673.         res = save_reduce(self, callable, arg_tup, state, args);
  1674.         goto finally;
  1675.     }
  1676.  
  1677.     /*
  1678.     if (PyObject_HasAttrString(args, "__class__")) {
  1679.         res = save_inst(self, args);
  1680.         goto finally;
  1681.     }
  1682.     */
  1683.  
  1684.     cPickle_ErrFormat(PicklingError, "Cannot pickle %s objects.", 
  1685.         "O", (PyObject *)type);
  1686.  
  1687. finally:
  1688.     Py_XDECREF(py_ob_id);
  1689.     Py_XDECREF(__reduce__);
  1690.     Py_XDECREF(t);
  1691.    
  1692.     return res;
  1693. }
  1694.  
  1695.  
  1696. static int
  1697. dump(Picklerobject *self, PyObject *args) {
  1698.     static char stop = STOP;
  1699.  
  1700.     if (save(self, args, 0) < 0)
  1701.         return -1;
  1702.  
  1703.     if ((*self->write_func)(self, &stop, 1) < 0)
  1704.         return -1;
  1705.  
  1706.     if ((*self->write_func)(self, NULL, 0) < 0)
  1707.         return -1;
  1708.  
  1709.     return 0;
  1710. }
  1711.  
  1712. static PyObject *
  1713. Pickler_dump(Picklerobject *self, PyObject *args) {
  1714.     PyObject *ob;
  1715.  
  1716.     UNLESS(PyArg_ParseTuple(args, "O", &ob))
  1717.         return NULL;
  1718.  
  1719.     if (dump(self, ob) < 0)
  1720.         return NULL;
  1721.  
  1722.     Py_INCREF(Py_None);
  1723.     return Py_None;
  1724. }
  1725.  
  1726.  
  1727. static PyObject *
  1728. dump_special(Picklerobject *self, PyObject *args) {
  1729.     static char stop = STOP;
  1730.  
  1731.     PyObject *callable, *arg_tup, *state = NULL;
  1732.     
  1733.     UNLESS(PyArg_ParseTuple(args, "OO|O", &callable, &arg_tup, &state))
  1734.         return NULL;
  1735.  
  1736.     UNLESS(PyTuple_Check(arg_tup)) {
  1737.         PyErr_SetString(PicklingError, "Second arg to dump_special must "
  1738.             "be tuple");
  1739.         return NULL;
  1740.     }
  1741.  
  1742.     if (save_reduce(self, callable, arg_tup, state, NULL) < 0)
  1743.         return NULL;
  1744.  
  1745.     if ((*self->write_func)(self, &stop, 1) < 0)
  1746.         return NULL;
  1747.  
  1748.     if ((*self->write_func)(self, NULL, 0) < 0)
  1749.         return NULL;
  1750.  
  1751.     Py_INCREF(Py_None);
  1752.     return Py_None;
  1753. }
  1754.  
  1755. static PyObject *
  1756. Pickle_clear_memo(Picklerobject *self, PyObject *args) {
  1757.   if(self->memo) PyDict_Clear(self->memo);
  1758.   Py_INCREF(Py_None);
  1759.   return Py_None;
  1760. }
  1761.  
  1762. static struct PyMethodDef Pickler_methods[] = {
  1763.   {"dump",          (PyCFunction)Pickler_dump,  1,
  1764.    "dump(object) --"
  1765.    "Write an object in pickle format to the object's pickle stream\n"
  1766.   },
  1767.   {"dump_special",  (PyCFunction)dump_special,  1,
  1768.    ""},
  1769.   {"clear_memo",  (PyCFunction)Pickle_clear_memo,  1,
  1770.    "clear_memo() -- Clear the picklers memo"},
  1771.   {NULL,                NULL}           /* sentinel */
  1772. };
  1773.  
  1774.  
  1775. static Picklerobject *
  1776. newPicklerobject(PyObject *file, int bin) {
  1777.     Picklerobject *self;
  1778.  
  1779.     UNLESS(self = PyObject_NEW(Picklerobject, &Picklertype))
  1780.         return NULL;
  1781.  
  1782.     self->fp = NULL;
  1783.     self->write = NULL;
  1784.     self->memo = NULL;
  1785.     self->arg = NULL;
  1786.     self->pers_func = NULL;
  1787.     self->inst_pers_func = NULL;
  1788.     self->write_buf = NULL;
  1789.     self->bin = bin;
  1790.     self->buf_size = 0;
  1791.     self->class_map = NULL;
  1792.     self->dispatch_table = NULL;
  1793.  
  1794.     Py_INCREF(file);
  1795.     self->file = file;
  1796.  
  1797.     UNLESS(self->memo = PyDict_New()) {
  1798.        Py_XDECREF((PyObject *)self);
  1799.        return NULL;
  1800.     }
  1801.  
  1802.     if (PyFile_Check(file)) {
  1803.         self->fp = PyFile_AsFile(file);
  1804.         self->write_func = write_file;
  1805.     }
  1806.     else if (PycStringIO_OutputCheck(file)) {
  1807.         self->write_func = write_cStringIO;
  1808.     }
  1809.     else if (file == Py_None) {
  1810.         self->write_func = write_none;
  1811.     }
  1812.     else {
  1813.         self->write_func = write_other;
  1814.  
  1815.         UNLESS(self->write = PyObject_GetAttr(file, write_str)) {
  1816.             PyErr_Clear();
  1817.             PyErr_SetString(PyExc_TypeError, "argument must have 'write' "
  1818.                 "attribute");
  1819.         goto err;
  1820.         }
  1821.  
  1822.         UNLESS(self->write_buf = 
  1823.             (char *)malloc(WRITE_BUF_SIZE * sizeof(char))) { 
  1824.             PyErr_NoMemory();
  1825.         goto err;
  1826.         }
  1827.     }
  1828.  
  1829.     if(PyEval_GetRestricted()) {
  1830.     /* Restricted execution, get private tables */
  1831.     PyObject *m;
  1832.  
  1833.     UNLESS(self->class_map=PyDict_New()) goto err;
  1834.     UNLESS(m=PyImport_Import(copy_reg_str)) goto err;
  1835.     self->dispatch_table=PyObject_GetAttr(m, dispatch_table_str);
  1836.     Py_DECREF(m);
  1837.     UNLESS(self->dispatch_table) goto err;
  1838.     }
  1839.     else {
  1840.     self->class_map=class_map;
  1841.     Py_INCREF(class_map);
  1842.     self->dispatch_table=dispatch_table;
  1843.     Py_INCREF(dispatch_table);
  1844.     }
  1845.  
  1846.     return self;
  1847.  
  1848. err:
  1849.     Py_DECREF((PyObject *)self);
  1850.     return NULL;
  1851. }
  1852.  
  1853.  
  1854. static PyObject *
  1855. get_Pickler(PyObject *self, PyObject *args) {
  1856.     PyObject *file;
  1857.     int bin = 0;
  1858.  
  1859.     UNLESS(PyArg_ParseTuple(args, "O|i", &file, &bin))  return NULL;
  1860.     return (PyObject *)newPicklerobject(file, bin);
  1861. }
  1862.  
  1863.  
  1864. static void
  1865. Pickler_dealloc(Picklerobject *self) {
  1866.     Py_XDECREF(self->write);
  1867.     Py_XDECREF(self->memo);
  1868.     Py_XDECREF(self->arg);
  1869.     Py_XDECREF(self->file);
  1870.     Py_XDECREF(self->pers_func);
  1871.     Py_XDECREF(self->inst_pers_func);
  1872.     Py_XDECREF(self->class_map);
  1873.     Py_XDECREF(self->dispatch_table);
  1874.  
  1875.     if (self->write_buf) {    
  1876.         free(self->write_buf);
  1877.     }
  1878.  
  1879.     PyMem_DEL(self);
  1880. }
  1881.  
  1882.  
  1883. static PyObject *
  1884. Pickler_getattr(Picklerobject *self, char *name) {
  1885.     if (strcmp(name, "persistent_id") == 0) {
  1886.         if (!self->pers_func) {
  1887.             PyErr_SetString(PyExc_AttributeError, name);
  1888.             return NULL;
  1889.         }
  1890.  
  1891.         Py_INCREF(self->pers_func);
  1892.         return self->pers_func;
  1893.     }
  1894.  
  1895.     if (strcmp(name, "memo") == 0) {
  1896.         if (!self->memo) {
  1897.             PyErr_SetString(PyExc_AttributeError, name);
  1898.             return NULL;
  1899.         }
  1900.  
  1901.         Py_INCREF(self->memo);
  1902.         return self->memo;
  1903.     }
  1904.  
  1905.     if (strcmp(name, "PicklingError") == 0) {
  1906.         Py_INCREF(PicklingError);
  1907.         return PicklingError;
  1908.     }
  1909.   
  1910.     return Py_FindMethod(Pickler_methods, (PyObject *)self, name);
  1911. }
  1912.  
  1913.  
  1914. int 
  1915. Pickler_setattr(Picklerobject *self, char *name, PyObject *value) {
  1916.     if (strcmp(name, "persistent_id") == 0) {
  1917.         Py_XDECREF(self->pers_func);
  1918.         self->pers_func = value;
  1919.         Py_INCREF(value);
  1920.         return 0;
  1921.     }
  1922.  
  1923.     if (strcmp(name, "inst_persistent_id") == 0) {
  1924.         Py_XDECREF(self->inst_pers_func);
  1925.         self->inst_pers_func = value;
  1926.         Py_INCREF(value);
  1927.         return 0;
  1928.     }
  1929.  
  1930.     PyErr_SetString(PyExc_AttributeError, name);
  1931.     return -1;
  1932. }
  1933.  
  1934.  
  1935. static char Picklertype__doc__[] =
  1936. "Objects that know how to pickle objects\n"
  1937. ;
  1938.  
  1939. static PyTypeObject Picklertype = {
  1940.     PyObject_HEAD_INIT(NULL)
  1941.     0,                            /*ob_size*/
  1942.     "Pickler",                    /*tp_name*/
  1943.     sizeof(Picklerobject),                /*tp_basicsize*/
  1944.     0,                            /*tp_itemsize*/
  1945.     /* methods */
  1946.     (destructor)Pickler_dealloc,  /*tp_dealloc*/
  1947.     (printfunc)0,         /*tp_print*/
  1948.     (getattrfunc)Pickler_getattr, /*tp_getattr*/
  1949.     (setattrfunc)Pickler_setattr, /*tp_setattr*/
  1950.     (cmpfunc)0,           /*tp_compare*/
  1951.     (reprfunc)0,          /*tp_repr*/
  1952.     0,                    /*tp_as_number*/
  1953.     0,            /*tp_as_sequence*/
  1954.     0,            /*tp_as_mapping*/
  1955.     (hashfunc)0,          /*tp_hash*/
  1956.     (ternaryfunc)0,               /*tp_call*/
  1957.     (reprfunc)0,          /*tp_str*/
  1958.  
  1959.     /* Space for future expansion */
  1960.     0L,0L,0L,0L,
  1961.     Picklertype__doc__ /* Documentation string */
  1962. };
  1963.  
  1964. static PyObject *
  1965. find_class(PyObject *class_map,
  1966.        PyObject *py_module_name, PyObject *py_global_name) {
  1967.     PyObject *global = 0, *t = 0, *module;
  1968.  
  1969.     UNLESS(t = PyTuple_New(2)) return NULL;
  1970.  
  1971.     PyTuple_SET_ITEM((PyTupleObject *)t, 0, py_module_name);
  1972.     Py_INCREF(py_module_name);
  1973.     PyTuple_SET_ITEM((PyTupleObject *)t, 1, py_global_name);
  1974.     Py_INCREF(py_global_name);
  1975.  
  1976.     global=PyDict_GetItem(class_map, t);
  1977.  
  1978.     if (global) {
  1979.       Py_DECREF(t);
  1980.       Py_INCREF(global);
  1981.       return global;
  1982.     }
  1983.  
  1984.     PyErr_Clear();
  1985.  
  1986.     UNLESS(module=PyImport_Import(py_module_name)) return NULL;
  1987.     global=PyObject_GetAttr(module, py_global_name);
  1988.     Py_DECREF(module);
  1989.     UNLESS(global) return NULL;
  1990.  
  1991.     if (PyDict_SetItem(class_map, t, global) < 0) global=NULL;
  1992.     Py_DECREF(t);
  1993.  
  1994.     return global;
  1995. }
  1996.  
  1997.  
  1998. static int
  1999. marker(Unpicklerobject *self) {
  2000.     if (self->num_marks < 1) {
  2001.         PyErr_SetString(UnpicklingError, "could not find MARK");
  2002.         return -1;
  2003.     }
  2004.  
  2005.     return self->marks[--self->num_marks];
  2006. }
  2007.  
  2008.     
  2009. static int
  2010. load_none(Unpicklerobject *self) {
  2011.     if (PyList_Append(self->stack, Py_None) < 0)
  2012.         return -1;
  2013.  
  2014.     return 0;
  2015. }
  2016.  
  2017.  
  2018. static int
  2019. load_int(Unpicklerobject *self) {
  2020.     PyObject *py_int = 0;
  2021.     char *endptr, *s;
  2022.     int len, res = -1;
  2023.     long l;
  2024.  
  2025.     if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
  2026.     UNLESS(s=pystrndup(s,len)) return -1;
  2027.  
  2028.     errno = 0;
  2029.     l = strtol(s, &endptr, 0);
  2030.  
  2031.     if (errno || (*endptr != '\n') || (endptr[1] != '\0')) {
  2032.         /* Hm, maybe we've got something long.  Let's try reading
  2033.        it as a Python long object. */
  2034.         errno=0;
  2035.         UNLESS(py_int=PyLong_FromString(s,&endptr,0)) goto finally;
  2036.  
  2037.     if ((*endptr != '\n') || (endptr[1] != '\0')) {
  2038.         PyErr_SetString(PyExc_ValueError,
  2039.                 "could not convert string to int");
  2040.         goto finally;
  2041.     }
  2042.     }
  2043.     else {
  2044.         UNLESS(py_int = PyInt_FromLong(l)) goto finally;
  2045.     }
  2046.  
  2047.     if (PyList_Append(self->stack, py_int) < 0) goto finally;
  2048.  
  2049.     res = 0;
  2050.  
  2051. finally:
  2052.     free(s);
  2053.     Py_XDECREF(py_int);
  2054.  
  2055.     return res;
  2056. }
  2057.  
  2058.  
  2059. static long 
  2060. calc_binint(char *s, int  x) {
  2061.     unsigned char c;
  2062.     int i;
  2063.     long l;
  2064.  
  2065.     for (i = 0, l = 0L; i < x; i++) {
  2066.         c = (unsigned char)s[i];
  2067.         l |= (long)c << (i * 8);
  2068.     }
  2069.  
  2070.     return l;
  2071. }
  2072.  
  2073.  
  2074. static int
  2075. load_binintx(Unpicklerobject *self, char *s, int  x) {
  2076.     PyObject *py_int = 0;
  2077.     long l;
  2078.  
  2079.     l = calc_binint(s, x);
  2080.  
  2081.     UNLESS(py_int = PyInt_FromLong(l))
  2082.         return -1;
  2083.     
  2084.     if (PyList_Append(self->stack, py_int) < 0) {
  2085.         Py_DECREF(py_int);
  2086.         return -1;
  2087.     }
  2088.  
  2089.     Py_DECREF(py_int);
  2090.     
  2091.     return 0;
  2092. }
  2093.  
  2094.  
  2095. static int
  2096. load_binint(Unpicklerobject *self) {
  2097.     char *s;
  2098.  
  2099.     if ((*self->read_func)(self, &s, 4) < 0)
  2100.         return -1;
  2101.  
  2102.     return load_binintx(self, s, 4);
  2103. }
  2104.  
  2105.  
  2106. static int
  2107. load_binint1(Unpicklerobject *self) {
  2108.     char *s;
  2109.  
  2110.     if ((*self->read_func)(self, &s, 1) < 0)
  2111.         return -1;
  2112.  
  2113.     return load_binintx(self, s, 1);
  2114. }
  2115.  
  2116.  
  2117. static int
  2118. load_binint2(Unpicklerobject *self) {
  2119.     char *s;
  2120.  
  2121.     if ((*self->read_func)(self, &s, 2) < 0)
  2122.         return -1;
  2123.  
  2124.     return load_binintx(self, s, 2);
  2125. }
  2126.     
  2127. static int
  2128. load_long(Unpicklerobject *self) {
  2129.     PyObject *l = 0;
  2130.     char *end, *s;
  2131.     int len, res = -1;
  2132.  
  2133.     if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
  2134.     UNLESS(s=pystrndup(s,len)) return -1;
  2135.  
  2136.     UNLESS(l = PyLong_FromString(s, &end, 0))
  2137.         goto finally;
  2138.  
  2139.     if (PyList_Append(self->stack, l) < 0)
  2140.         goto finally;
  2141.  
  2142.     res = 0;
  2143.  
  2144. finally:
  2145.     free(s);
  2146.     Py_XDECREF(l);
  2147.  
  2148.     return res;
  2149. }
  2150.  
  2151.  
  2152. static int
  2153. load_float(Unpicklerobject *self) {
  2154.     PyObject *py_float = 0;
  2155.     char *endptr, *s;
  2156.     int len, res = -1;
  2157.     double d;
  2158.  
  2159.     if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
  2160.     UNLESS(s=pystrndup(s,len)) return -1;
  2161.  
  2162.     errno = 0;
  2163.     d = strtod(s, &endptr);
  2164.  
  2165.     if (errno || (endptr[0] != '\n') || (endptr[1] != '\0')) {
  2166.         PyErr_SetString(PyExc_ValueError, 
  2167.         "could not convert string to float");
  2168.         goto finally;
  2169.     }
  2170.  
  2171.     UNLESS(py_float = PyFloat_FromDouble(d))
  2172.         goto finally;
  2173.  
  2174.     if (PyList_Append(self->stack, py_float) < 0)
  2175.         goto finally;
  2176.  
  2177.     res = 0;
  2178.  
  2179. finally:
  2180.     free(s);
  2181.     Py_XDECREF(py_float);
  2182.  
  2183.     return res;
  2184. }
  2185.  
  2186. static int
  2187. load_binfloat(Unpicklerobject *self) {
  2188.     PyObject *py_float = 0;
  2189.     int s, e, res = -1;
  2190.     long fhi, flo;
  2191.     double x;
  2192.     char *p;
  2193.  
  2194.     if ((*self->read_func)(self, &p, 8) < 0)
  2195.         return -1;
  2196.  
  2197.     /* First byte */
  2198.     s = (*p>>7) & 1;
  2199.     e = (*p & 0x7F) << 4;
  2200.     p++;
  2201.  
  2202.     /* Second byte */
  2203.     e |= (*p>>4) & 0xF;
  2204.     fhi = (*p & 0xF) << 24;
  2205.     p++;
  2206.  
  2207.     /* Third byte */
  2208.     fhi |= (*p & 0xFF) << 16;
  2209.     p++;
  2210.  
  2211.     /* Fourth byte */
  2212.     fhi |= (*p & 0xFF) << 8;
  2213.     p++;
  2214.  
  2215.     /* Fifth byte */
  2216.     fhi |= *p & 0xFF;
  2217.     p++;
  2218.  
  2219.     /* Sixth byte */
  2220.     flo = (*p & 0xFF) << 16;
  2221.     p++;
  2222.  
  2223.     /* Seventh byte */
  2224.     flo |= (*p & 0xFF) << 8;
  2225.     p++;
  2226.  
  2227.     /* Eighth byte */
  2228.     flo |= *p & 0xFF;
  2229.  
  2230.     x = (double)fhi + (double)flo / 16777216.0; /* 2**24 */
  2231.     x /= 268435456.0; /* 2**28 */
  2232.  
  2233.     /* XXX This sadly ignores Inf/NaN */
  2234.     if (e == 0)
  2235.         e = -1022;
  2236.     else {
  2237.         x += 1.0;
  2238.         e -= 1023;
  2239.     }
  2240.     x = ldexp(x, e);
  2241.  
  2242.     if (s)
  2243.         x = -x;
  2244.  
  2245.     UNLESS(py_float = PyFloat_FromDouble(x))
  2246.         goto finally;
  2247.  
  2248.     if (PyList_Append(self->stack, py_float) < 0) 
  2249.         goto finally;
  2250.  
  2251.     res = 0;
  2252.  
  2253. finally:
  2254.     Py_XDECREF(py_float);
  2255.  
  2256.     return res;
  2257. }
  2258.  
  2259. static int
  2260. load_string(Unpicklerobject *self) {
  2261.     PyObject *str = 0;
  2262.     int len, res = -1, nslash;
  2263.     char *s, q, *p;
  2264.  
  2265.     static PyObject *eval_dict = 0;
  2266.  
  2267.     if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
  2268.     UNLESS(s=pystrndup(s,len)) return -1;
  2269.  
  2270.     /* Check for unquoted quotes (evil strings) */
  2271.     q=*s;
  2272.     if(q != '"' && q != '\'') goto insecure;
  2273.     for(p=s+1, nslash=0; *p; p++)
  2274.       {
  2275.     if(*p==q && nslash%2==0) break;
  2276.     if(*p=='\\') nslash++;
  2277.     else nslash=0;
  2278.       }
  2279.     if(*p==q)
  2280.       {
  2281.     for(p++; *p; p++) if(*p > ' ') goto insecure;
  2282.       }
  2283.     else goto insecure;
  2284.     /********************************************/
  2285.  
  2286.     UNLESS(eval_dict)
  2287.         UNLESS(eval_dict = Py_BuildValue("{s{}}", "__builtins__"))
  2288.             goto finally;
  2289.  
  2290.     UNLESS(str = PyRun_String(s, Py_eval_input, eval_dict, eval_dict))
  2291.         goto finally;
  2292.  
  2293.     if (PyList_Append(self->stack, str) < 0)
  2294.         goto finally;
  2295.  
  2296.     res = 0;
  2297.  
  2298. finally:
  2299.     free(s);
  2300.     Py_XDECREF(str);
  2301.  
  2302.     return res;
  2303.     
  2304. insecure:
  2305.     free(s);
  2306.     PyErr_SetString(PyExc_ValueError,"insecure string pickle");
  2307.     return -1;
  2308. } 
  2309.  
  2310.  
  2311. static int
  2312. load_binstring(Unpicklerobject *self) {
  2313.     PyObject *py_string = 0;
  2314.     long l;
  2315.     int res = -1;
  2316.     char *s;
  2317.  
  2318.     if ((*self->read_func)(self, &s, 4) < 0)
  2319.         goto finally;
  2320.  
  2321.     l = calc_binint(s, 4);
  2322.  
  2323.     if ((*self->read_func)(self, &s, l) < 0)
  2324.         goto finally;
  2325.  
  2326.     UNLESS(py_string = PyString_FromStringAndSize(s, l))
  2327.         goto finally;
  2328.  
  2329.     if (PyList_Append(self->stack, py_string) < 0)
  2330.         goto finally;
  2331.  
  2332.     res = 0;
  2333.  
  2334. finally:
  2335.     Py_XDECREF(py_string);
  2336.  
  2337.     return res;
  2338. }
  2339.  
  2340.  
  2341. static int
  2342. load_short_binstring(Unpicklerobject *self) {
  2343.     PyObject *py_string = 0;
  2344.     unsigned char l;  
  2345.     int res = -1;
  2346.     char *s;
  2347.  
  2348.     if ((*self->read_func)(self, &s, 1) < 0)
  2349.         return -1;
  2350.  
  2351.     l = (unsigned char)s[0];
  2352.  
  2353.     if ((*self->read_func)(self, &s, l) < 0)
  2354.         goto finally;
  2355.  
  2356.     UNLESS(py_string = PyString_FromStringAndSize(s, l))
  2357.         goto finally;
  2358.  
  2359.     if (PyList_Append(self->stack, py_string) < 0)
  2360.         goto finally;
  2361.  
  2362.     res = 0;
  2363.  
  2364. finally:
  2365.     Py_XDECREF(py_string);
  2366.  
  2367.     return res;
  2368. } 
  2369.  
  2370.  
  2371. static int
  2372. load_tuple(Unpicklerobject *self) {
  2373.     PyObject *tup = 0, *slice = 0, *list = 0;
  2374.     int i, j, res = -1;
  2375.  
  2376.     if ((i = marker(self)) < 0)
  2377.         goto finally;
  2378.  
  2379.     if ((j = PyList_Size(self->stack)) < 0)  
  2380.         goto finally;
  2381.  
  2382.     UNLESS(slice = PyList_GetSlice(self->stack, i, j))
  2383.         goto finally;
  2384.   
  2385.     UNLESS(tup = PySequence_Tuple(slice))
  2386.         goto finally;
  2387.  
  2388.     UNLESS(list = PyList_New(1))
  2389.         goto finally;
  2390.  
  2391.     Py_INCREF(tup);
  2392.     if (PyList_SetItem(list, 0, tup) < 0)
  2393.         goto finally;
  2394.  
  2395.     if (PyList_SetSlice(self->stack, i, j, list) < 0)
  2396.         goto finally;
  2397.  
  2398.     res = 0;
  2399.  
  2400. finally:
  2401.     Py_XDECREF(tup);
  2402.     Py_XDECREF(list);
  2403.     Py_XDECREF(slice);
  2404.  
  2405.     return res;
  2406. }
  2407.  
  2408. static int
  2409. load_empty_tuple(Unpicklerobject *self) {
  2410.     PyObject *tup = 0;
  2411.     int res;
  2412.  
  2413.     UNLESS(tup=PyTuple_New(0)) return -1;
  2414.     res=PyList_Append(self->stack, tup);
  2415.     Py_DECREF(tup);
  2416.     return res;
  2417. }
  2418.  
  2419. static int
  2420. load_empty_list(Unpicklerobject *self) {
  2421.     PyObject *list = 0;
  2422.     int res;
  2423.  
  2424.     UNLESS(list=PyList_New(0)) return -1;
  2425.     res=PyList_Append(self->stack, list);
  2426.     Py_DECREF(list);
  2427.     return res;
  2428. }
  2429.  
  2430. static int
  2431. load_empty_dict(Unpicklerobject *self) {
  2432.     PyObject *dict = 0;
  2433.     int res;
  2434.  
  2435.     UNLESS(dict=PyDict_New()) return -1;
  2436.     res=PyList_Append(self->stack, dict);
  2437.     Py_DECREF(dict);
  2438.     return res;
  2439. }
  2440.  
  2441.  
  2442. static int
  2443. load_list(Unpicklerobject *self) {
  2444.     PyObject *list = 0, *slice = 0;
  2445.     int i, j, l, res = -1;
  2446.  
  2447.     if ((i = marker(self)) < 0)
  2448.         goto finally;
  2449.  
  2450.     if ((j = PyList_Size(self->stack)) < 0)
  2451.         goto finally;
  2452.  
  2453.     UNLESS(slice = PyList_GetSlice(self->stack, i, j))
  2454.         goto finally;
  2455.  
  2456.     if((l=PyList_Size(slice)) < 0)
  2457.         goto finally;
  2458.  
  2459.     if(l) {
  2460.       UNLESS(list = PyList_New(1))
  2461.         goto finally;
  2462.  
  2463.       Py_INCREF(slice);
  2464.       if (PyList_SetItem(list, 0, slice) < 0)
  2465.         goto finally;
  2466.       
  2467.       if (PyList_SetSlice(self->stack, i, j, list) < 0)
  2468.         goto finally;
  2469.     } else {
  2470.       if(PyList_Append(self->stack,slice) < 0)
  2471.     goto finally;
  2472.     }
  2473.  
  2474.     res = 0;
  2475.  
  2476. finally:
  2477.     Py_XDECREF(list);
  2478.     Py_XDECREF(slice);
  2479.  
  2480.     return res;
  2481. }
  2482.  
  2483. static int
  2484. load_dict(Unpicklerobject *self) {
  2485.     PyObject *list = 0, *dict = 0, *key = 0, *value = 0;
  2486.     int i, j, k, res = -1;
  2487.  
  2488.     if ((i = marker(self)) < 0)
  2489.         goto finally;
  2490.  
  2491.     if ((j = PyList_Size(self->stack)) < 0)
  2492.         goto finally;
  2493.  
  2494.     UNLESS(dict = PyDict_New())
  2495.         goto finally;
  2496.  
  2497.     for (k = i; k < j; k += 2) {
  2498.         UNLESS(key = PyList_GET_ITEM((PyListObject *)self->stack, k))
  2499.             goto finally;
  2500.  
  2501.         UNLESS(value = PyList_GET_ITEM((PyListObject *)self->stack, k + 1))
  2502.             goto finally;
  2503.  
  2504.         if (PyDict_SetItem(dict, key, value) < 0)
  2505.             goto finally;
  2506.     }
  2507.  
  2508.     if(j) {
  2509.  
  2510.       UNLESS(list = PyList_New(1))
  2511.         goto finally;
  2512.  
  2513.       Py_INCREF(dict);
  2514.       if (PyList_SetItem(list, 0, dict) < 0)
  2515.         goto finally;
  2516.  
  2517.       if (PyList_SetSlice(self->stack, i, j, list) < 0)
  2518.         goto finally;
  2519.     }
  2520.     else 
  2521.       if(PyList_Append(self->stack, dict) < 0)
  2522.     goto finally;
  2523.  
  2524.     res = 0;
  2525.  
  2526. finally:
  2527.     Py_XDECREF(dict);
  2528.     Py_XDECREF(list);
  2529.  
  2530.     return res;
  2531. }
  2532.  
  2533. static PyObject *
  2534. Instance_New(PyObject *cls, PyObject *args) {
  2535.   int has_key;
  2536.   PyObject *safe=0, *r=0;
  2537.  
  2538.   if (PyClass_Check(cls)) {
  2539.       int l;
  2540.       
  2541.       if((l=PyObject_Length(args)) < 0) goto err;
  2542.       UNLESS(l) {
  2543.       PyObject *__getinitargs__;
  2544.  
  2545.       UNLESS(__getinitargs__=PyObject_GetAttr(cls, __getinitargs___str)) {
  2546.           /* We have a class with no __getinitargs__, so bypass usual
  2547.          construction  */
  2548.           PyInstanceObject *inst;
  2549.  
  2550.           PyErr_Clear();
  2551.           UNLESS(inst=PyObject_NEW(PyInstanceObject, &PyInstance_Type))
  2552.         goto err;
  2553.           inst->in_class=(PyClassObject*)cls;
  2554.           Py_INCREF(cls);
  2555.           UNLESS(inst->in_dict=PyDict_New()) {
  2556.         Py_DECREF(inst);
  2557.         goto err;
  2558.           }
  2559.  
  2560.           return (PyObject *)inst;
  2561.         }
  2562.       Py_DECREF(__getinitargs__);
  2563.     }
  2564.       
  2565.       if((r=PyInstance_New(cls, args, NULL))) return r;
  2566.       else goto err;
  2567.     }
  2568.        
  2569.   
  2570.   if ((has_key = cPickle_PyMapping_HasKey(safe_constructors, cls)) < 0)
  2571.     goto err;
  2572.     
  2573.   if (!has_key)
  2574.     if(!(safe = PyObject_GetAttr(cls, __safe_for_unpickling___str)) ||
  2575.        !PyObject_IsTrue(safe)) {
  2576.       cPickle_ErrFormat(UnpicklingError, "%s is not safe for unpickling", "O", cls);
  2577.       Py_XDECREF(safe);
  2578.       return NULL;
  2579.   }
  2580.  
  2581.   if(args==Py_None)
  2582.     {
  2583.       /* Special case, call cls.__basicnew__() */
  2584.       PyObject *basicnew;
  2585.       
  2586.       UNLESS(basicnew=PyObject_GetAttr(cls, __basicnew___str)) return NULL;
  2587.       r=PyObject_CallObject(basicnew, NULL);
  2588.       Py_DECREF(basicnew);
  2589.       if(r) return r;
  2590.     }
  2591.  
  2592.   if((r=PyObject_CallObject(cls, args))) return r;
  2593.  
  2594. err:
  2595.   {
  2596.     PyObject *tp, *v, *tb;
  2597.  
  2598.     PyErr_Fetch(&tp, &v, &tb);
  2599.     if((r=Py_BuildValue("OOO",v,cls,args))) {
  2600.     Py_XDECREF(v);
  2601.     v=r;
  2602.       }
  2603.     PyErr_Restore(tp,v,tb);
  2604.   }
  2605.   return NULL;
  2606. }
  2607.   
  2608.  
  2609. static int
  2610. load_obj(Unpicklerobject *self) {
  2611.     PyObject *class = 0, *slice = 0, *tup = 0, *obj = 0;
  2612.     int i, len, res = -1;
  2613.  
  2614.     if ((i = marker(self)) < 0)
  2615.         goto finally;
  2616.  
  2617.     if ((len = PyList_Size(self->stack)) < 0)
  2618.         goto finally;
  2619.  
  2620.     UNLESS(slice = PyList_GetSlice(self->stack, i + 1, len))
  2621.         goto finally;
  2622.  
  2623.     UNLESS(tup = PySequence_Tuple(slice))
  2624.         goto finally;
  2625.  
  2626.     class = PyList_GET_ITEM((PyListObject *)self->stack, i);
  2627.     Py_INCREF(class);
  2628.  
  2629.     UNLESS(obj = Instance_New(class, tup))
  2630.         goto finally;
  2631.  
  2632.     if (DEL_LIST_SLICE(self->stack, i, len) < 0)
  2633.         goto finally;
  2634.  
  2635.     if (PyList_Append(self->stack, obj) < 0)
  2636.         goto finally;
  2637.   
  2638.     res = 0;
  2639.  
  2640. finally:
  2641.     
  2642.     Py_XDECREF(class);
  2643.     Py_XDECREF(slice);
  2644.     Py_XDECREF(tup);
  2645.     Py_XDECREF(obj);
  2646.  
  2647.     return res;
  2648. }
  2649.  
  2650.  
  2651. static int
  2652. load_inst(Unpicklerobject *self) {
  2653.     PyObject *arg_tup = 0, *arg_slice = 0, *class = 0, *obj = 0,
  2654.              *module_name = 0, *class_name = 0;
  2655.     int i, j, len, res = -1;
  2656.     char *s;
  2657.  
  2658.     if ((i = marker(self)) < 0) goto finally;
  2659.  
  2660.     if ((j = PyList_Size(self->stack)) < 0) goto finally;
  2661.  
  2662.     UNLESS(arg_slice = PyList_GetSlice(self->stack, i, j)) goto finally;
  2663.  
  2664.     UNLESS(arg_tup = PySequence_Tuple(arg_slice)) goto finally;
  2665.  
  2666.     if (DEL_LIST_SLICE(self->stack, i, j) < 0) goto finally;
  2667.  
  2668.     if ((len = (*self->readline_func)(self, &s)) < 0) goto finally;
  2669.  
  2670.     UNLESS(module_name = PyString_FromStringAndSize(s, len - 1)) goto finally;
  2671.  
  2672.     if ((len = (*self->readline_func)(self, &s)) < 0) goto finally;
  2673.  
  2674.     UNLESS(class_name = PyString_FromStringAndSize(s, len - 1)) goto finally;
  2675.  
  2676.     UNLESS(class = find_class(self->class_map, module_name, class_name))
  2677.         goto finally;
  2678.  
  2679.     UNLESS(obj = Instance_New(class, arg_tup)) goto finally;
  2680.  
  2681.     if (PyList_Append(self->stack, obj) < 0) goto finally;
  2682.  
  2683.     res = 0;
  2684.  
  2685. finally:
  2686.     Py_XDECREF(class);
  2687.     Py_XDECREF(arg_slice);
  2688.     Py_XDECREF(arg_tup);
  2689.     Py_XDECREF(obj);
  2690.     Py_XDECREF(module_name);
  2691.     Py_XDECREF(class_name);
  2692.  
  2693.     return res;
  2694. }
  2695.  
  2696.  
  2697. static int
  2698. load_global(Unpicklerobject *self) {
  2699.     PyObject *class = 0, *module_name = 0, *class_name = 0;
  2700.     int res = -1, len;
  2701.     char *s;
  2702.  
  2703.     if ((len = (*self->readline_func)(self, &s)) < 0)
  2704.         goto finally;
  2705.  
  2706.     UNLESS(module_name = PyString_FromStringAndSize(s, len - 1))
  2707.         goto finally;
  2708.  
  2709.     if ((len = (*self->readline_func)(self, &s)) < 0)
  2710.         goto finally;
  2711.  
  2712.     UNLESS(class_name = PyString_FromStringAndSize(s, len - 1))
  2713.         goto finally;
  2714.  
  2715.     UNLESS(class = find_class(self->class_map, module_name, class_name))
  2716.         goto finally;
  2717.  
  2718.     if (PyList_Append(self->stack, class) < 0)
  2719.         goto finally;
  2720.  
  2721.     res = 0;
  2722.  
  2723. finally:
  2724.     Py_XDECREF(class);
  2725.     Py_XDECREF(module_name);
  2726.     Py_XDECREF(class_name);
  2727.  
  2728.     return res;
  2729. }
  2730.  
  2731.  
  2732. static int
  2733. load_persid(Unpicklerobject *self) {
  2734.     PyObject *pid = 0, *pers_load_val = 0;
  2735.     int len, res = -1;
  2736.     char *s;
  2737.  
  2738.     if (self->pers_func) {
  2739.         if ((len = (*self->readline_func)(self, &s)) < 0)
  2740.             goto finally;
  2741.   
  2742.         UNLESS(pid = PyString_FromStringAndSize(s, len - 1))
  2743.            goto finally;
  2744.  
  2745.     if(PyList_Check(self->pers_func)) {
  2746.         if(PyList_Append(self->pers_func, pid) < 0) goto finally;
  2747.         pers_load_val=pid;
  2748.         Py_INCREF(pid);
  2749.       }
  2750.     else {
  2751.         UNLESS(self->arg)
  2752.           UNLESS(self->arg = PyTuple_New(1))
  2753.             goto finally;
  2754.  
  2755.         Py_INCREF(pid);
  2756.         if (PyTuple_SetItem(self->arg, 0, pid) < 0)
  2757.           goto finally;
  2758.       
  2759.         UNLESS(pers_load_val = 
  2760.            PyObject_CallObject(self->pers_func, self->arg))
  2761.           goto finally;
  2762.       }
  2763.     if (PyList_Append(self->stack, pers_load_val) < 0)
  2764.       goto finally;
  2765.     }
  2766.     else {
  2767.       PyErr_SetString(UnpicklingError,
  2768.               "A load persistent id instruction was encountered,\n"
  2769.               "but no persistent_load function was specified.");
  2770.       goto finally;
  2771.     }
  2772.  
  2773.     res = 0;
  2774.  
  2775. finally:
  2776.     Py_XDECREF(pid);
  2777.     Py_XDECREF(pers_load_val);
  2778.  
  2779.     return res;
  2780. }
  2781.  
  2782.  
  2783. static int
  2784. load_binpersid(Unpicklerobject *self) {
  2785.     PyObject *pid = 0, *pers_load_val = 0;
  2786.     int len, res = -1;
  2787.  
  2788.     if (self->pers_func) {
  2789.         if ((len = PyList_Size(self->stack)) < 0)
  2790.             goto finally;
  2791.  
  2792.         pid = PyList_GET_ITEM((PyListObject *)self->stack, len - 1);
  2793.         Py_INCREF(pid);
  2794.  
  2795.         if (DEL_LIST_SLICE(self->stack, len - 1, len) < 0)
  2796.             goto finally;
  2797.  
  2798.     if(PyList_Check(self->pers_func)) {
  2799.         if(PyList_Append(self->pers_func, pid) < 0) goto finally;
  2800.         pers_load_val=pid;
  2801.         Py_INCREF(pid);
  2802.       }
  2803.     else {
  2804.       UNLESS(self->arg)
  2805.             UNLESS(self->arg = PyTuple_New(1))
  2806.         goto finally;
  2807.  
  2808.       Py_INCREF(pid);
  2809.       if (PyTuple_SetItem(self->arg, 0, pid) < 0)
  2810.             goto finally;
  2811.  
  2812.       UNLESS(pers_load_val = 
  2813.          PyObject_CallObject(self->pers_func, self->arg))
  2814.             goto finally;
  2815.     }
  2816.         if (PyList_Append(self->stack, pers_load_val) < 0)
  2817.             goto finally;
  2818.     }
  2819.     else {
  2820.       PyErr_SetString(UnpicklingError,
  2821.               "A load persistent id instruction was encountered,\n"
  2822.               "but no persistent_load function was specified.");
  2823.       goto finally;
  2824.     }
  2825.  
  2826.     res = 0;
  2827.  
  2828. finally:
  2829.     Py_XDECREF(pid);
  2830.     Py_XDECREF(pers_load_val);
  2831.  
  2832.     return res;
  2833. }
  2834.  
  2835.  
  2836. static int
  2837. load_pop(Unpicklerobject *self) {
  2838.     int len;
  2839.  
  2840.     if ((len = PyList_Size(self->stack)) < 0)  
  2841.         return -1;
  2842.  
  2843.     if ((self->num_marks > 0) && 
  2844.         (self->marks[self->num_marks - 1] == len))
  2845.         self->num_marks--;
  2846.     else if (DEL_LIST_SLICE(self->stack, len - 1, len) < 0)  
  2847.         return -1;
  2848.  
  2849.     return 0;
  2850. }
  2851.  
  2852.  
  2853. static int
  2854. load_pop_mark(Unpicklerobject *self) {
  2855.     int i, len;
  2856.  
  2857.     if ((i = marker(self)) < 0)
  2858.         return -1;
  2859.  
  2860.     if ((len = PyList_Size(self->stack)) < 0)
  2861.         return -1;
  2862.  
  2863.     if (DEL_LIST_SLICE(self->stack, i, len) < 0)
  2864.         return -1;
  2865.  
  2866.     return 0;
  2867. }
  2868.  
  2869.  
  2870. static int
  2871. load_dup(Unpicklerobject *self) {
  2872.     PyObject *last;
  2873.     int len;
  2874.  
  2875.     if ((len = PyList_Size(self->stack)) < 0)
  2876.         return -1;
  2877.   
  2878.     UNLESS(last = PyList_GetItem(self->stack, len - 1))  
  2879.         return -1;
  2880.  
  2881.     if (PyList_Append(self->stack, last) < 0)
  2882.         return -1;
  2883.  
  2884.     return 0;
  2885. }
  2886.  
  2887.  
  2888. static int
  2889. load_get(Unpicklerobject *self) {
  2890.     PyObject *py_str = 0, *value = 0;
  2891.     int len, res = -1;
  2892.     char *s;
  2893.  
  2894.     if ((len = (*self->readline_func)(self, &s)) < 0)
  2895.         goto finally;
  2896.  
  2897.     UNLESS(py_str = PyString_FromStringAndSize(s, len - 1))
  2898.         goto finally;
  2899.   
  2900.     UNLESS(value = PyDict_GetItem(self->memo, py_str))  
  2901.         goto finally;
  2902.  
  2903.     if (PyList_Append(self->stack, value) < 0)
  2904.         goto finally;
  2905.  
  2906.     res = 0;
  2907.  
  2908. finally:
  2909.     Py_XDECREF(py_str);
  2910.  
  2911.     return res;
  2912. }
  2913.  
  2914.  
  2915. static int
  2916. load_binget(Unpicklerobject *self) {
  2917.     PyObject *py_key = 0, *value = 0;
  2918.     unsigned char key;
  2919.     int res = -1;
  2920.     char *s;
  2921.  
  2922.     if ((*self->read_func)(self, &s, 1) < 0)
  2923.         goto finally;
  2924.  
  2925.     key = (unsigned char)s[0];
  2926.  
  2927.     UNLESS(py_key = PyInt_FromLong((long)key))
  2928.         goto finally;
  2929.  
  2930.     UNLESS(value = PyDict_GetItem(self->memo, py_key))  
  2931.         goto finally;
  2932.  
  2933.     if (PyList_Append(self->stack, value) < 0)
  2934.         goto finally;
  2935.  
  2936.     res = 0;
  2937.  
  2938. finally:
  2939.     Py_XDECREF(py_key);
  2940.  
  2941.     return res;
  2942. }
  2943.  
  2944.  
  2945. static int
  2946. load_long_binget(Unpicklerobject *self) {
  2947.     PyObject *py_key = 0, *value = 0;
  2948.     unsigned char c, *s;
  2949.     long key;
  2950.     int res = -1;
  2951.  
  2952.     if ((*self->read_func)(self, &s, 4) < 0)
  2953.         goto finally;
  2954.  
  2955.     c = (unsigned char)s[0];
  2956.     key = (long)c;
  2957.     c = (unsigned char)s[1];
  2958.     key |= (long)c << 8;
  2959.     c = (unsigned char)s[2];
  2960.     key |= (long)c << 16;
  2961.     c = (unsigned char)s[3];
  2962.     key |= (long)c << 24;
  2963.  
  2964.     UNLESS(py_key = PyInt_FromLong(key))
  2965.         goto finally;
  2966.  
  2967.     UNLESS(value = PyDict_GetItem(self->memo, py_key))  
  2968.         goto finally;
  2969.  
  2970.     if (PyList_Append(self->stack, value) < 0)
  2971.         goto finally;
  2972.  
  2973.     res = 0;
  2974.  
  2975. finally:
  2976.     Py_XDECREF(py_key);
  2977.  
  2978.     return res;
  2979. }
  2980.  
  2981.  
  2982. static int
  2983. load_put(Unpicklerobject *self) {
  2984.     PyObject *py_str = 0, *value = 0;
  2985.     int len, res = -1;
  2986.     char *s;
  2987.  
  2988.     if ((len = (*self->readline_func)(self, &s)) < 0)
  2989.         goto finally;
  2990.  
  2991.     UNLESS(py_str = PyString_FromStringAndSize(s, len - 1))
  2992.         goto finally;
  2993.  
  2994.     if ((len = PyList_Size(self->stack)) < 0)
  2995.         goto finally;
  2996.  
  2997.     UNLESS(value = PyList_GetItem(self->stack, len - 1))  
  2998.         goto finally;
  2999.  
  3000.     if (PyDict_SetItem(self->memo, py_str, value) < 0)  
  3001.         goto finally;
  3002.  
  3003.     res = 0;
  3004.  
  3005. finally:
  3006.     Py_XDECREF(py_str);
  3007.  
  3008.     return res;
  3009. }
  3010.  
  3011.  
  3012. static int
  3013. load_binput(Unpicklerobject *self) {
  3014.     PyObject *py_key = 0, *value = 0;
  3015.     unsigned char key, *s;
  3016.     int len, res = -1;
  3017.  
  3018.     if ((*self->read_func)(self, &s, 1) < 0)
  3019.         goto finally;
  3020.  
  3021.     key = (unsigned char)s[0];
  3022.  
  3023.     UNLESS(py_key = PyInt_FromLong((long)key))
  3024.         goto finally;
  3025.  
  3026.     if ((len = PyList_Size(self->stack)) < 0)
  3027.         goto finally;
  3028.  
  3029.     UNLESS(value = PyList_GetItem(self->stack, len - 1))  
  3030.         goto finally;
  3031.  
  3032.     if (PyDict_SetItem(self->memo, py_key, value) < 0)  
  3033.         goto finally;
  3034.  
  3035.     res = 0;
  3036.  
  3037. finally:
  3038.     Py_XDECREF(py_key);
  3039.  
  3040.     return res;
  3041. }
  3042.  
  3043.  
  3044. static int
  3045. load_long_binput(Unpicklerobject *self) {
  3046.     PyObject *py_key = 0, *value = 0;
  3047.     long key;
  3048.     unsigned char c, *s;
  3049.     int len, res = -1;
  3050.  
  3051.     if ((*self->read_func)(self, &s, 4) < 0)
  3052.         goto finally;
  3053.  
  3054.     c = (unsigned char)s[0];
  3055.     key = (long)c;
  3056.     c = (unsigned char)s[1];
  3057.     key |= (long)c << 8;
  3058.     c = (unsigned char)s[2];
  3059.     key |= (long)c << 16;
  3060.     c = (unsigned char)s[3];
  3061.     key |= (long)c << 24;
  3062.  
  3063.     UNLESS(py_key = PyInt_FromLong(key))
  3064.         goto finally;
  3065.  
  3066.     if ((len = PyList_Size(self->stack)) < 0)
  3067.         goto finally;
  3068.  
  3069.     UNLESS(value = PyList_GetItem(self->stack, len - 1))  
  3070.         goto finally;
  3071.  
  3072.     if (PyDict_SetItem(self->memo, py_key, value) < 0)  
  3073.         goto finally;
  3074.  
  3075.     res = 0;
  3076.  
  3077. finally:
  3078.     Py_XDECREF(py_key);
  3079.  
  3080.     return res;
  3081. }
  3082.  
  3083.  
  3084. static int 
  3085. do_append(Unpicklerobject *self, int  x) {
  3086.     PyObject *value = 0, *list = 0, *append_method = 0;
  3087.     int len, i;
  3088.  
  3089.     if ((len = PyList_Size(self->stack)) < 0)  
  3090.         return -1;
  3091.  
  3092.     UNLESS(list = PyList_GetItem(self->stack, x - 1))  
  3093.         goto err;
  3094.  
  3095.     if (PyList_Check(list)) {
  3096.         PyObject *slice = 0;
  3097.         int list_len;
  3098.        
  3099.         UNLESS(slice = PyList_GetSlice(self->stack, x, len))
  3100.             return -1;
  3101.   
  3102.         list_len = PyList_Size(list);
  3103.         if (PyList_SetSlice(list, list_len, list_len, slice) < 0) {
  3104.             Py_DECREF(slice);
  3105.             return -1;
  3106.         }
  3107.  
  3108.         Py_DECREF(slice);
  3109.     }
  3110.     else {
  3111.  
  3112.         UNLESS(append_method = PyObject_GetAttr(list, append_str))
  3113.             return -1;
  3114.          
  3115.         for (i = x; i < len; i++) {
  3116.         PyObject *junk;
  3117.  
  3118.             UNLESS(value = PyList_GetItem(self->stack, i))  
  3119.                 return -1;
  3120.  
  3121.         UNLESS(self->arg)
  3122.           UNLESS(self->arg = PyTuple_New(1)) 
  3123.             goto err;
  3124.         
  3125.         Py_INCREF(value);
  3126.         if (PyTuple_SetItem(self->arg, 0, value) < 0) 
  3127.           goto err;
  3128.         
  3129.         UNLESS(junk = PyObject_CallObject(append_method, self->arg)) 
  3130.           goto err;
  3131.         Py_DECREF(junk);
  3132.         }
  3133.     }
  3134.  
  3135.     if (DEL_LIST_SLICE(self->stack, x, len) < 0)  
  3136.         goto err;
  3137.  
  3138.     Py_XDECREF(append_method);
  3139.  
  3140.     return 0;
  3141.  
  3142. err:
  3143.     Py_XDECREF(append_method);
  3144.  
  3145.     return -1;
  3146. }
  3147.  
  3148.     
  3149. static int
  3150. load_append(Unpicklerobject *self) {
  3151.     return do_append(self, PyList_Size(self->stack) - 1);
  3152. }
  3153.  
  3154.  
  3155. static int
  3156. load_appends(Unpicklerobject *self) {
  3157.     return do_append(self, marker(self));
  3158. }
  3159.  
  3160.  
  3161. static int
  3162. do_setitems(Unpicklerobject *self, int  x) {
  3163.     PyObject *value = 0, *key = 0, *dict = 0;
  3164.     int len, i, res = -1;
  3165.  
  3166.     if ((len = PyList_Size(self->stack)) < 0)  
  3167.         goto finally;
  3168.  
  3169.     UNLESS(dict = PyList_GetItem(self->stack, x - 1))
  3170.         goto finally;
  3171.  
  3172.     for (i = x; i < len; i += 2) {
  3173.         UNLESS(key = PyList_GetItem(self->stack, i))  
  3174.             goto finally;
  3175.  
  3176.         UNLESS(value = PyList_GetItem(self->stack, i + 1))
  3177.             goto finally;
  3178.  
  3179.         if (PyObject_SetItem(dict, key, value) < 0)  
  3180.             goto finally;
  3181.     }
  3182.  
  3183.     if (DEL_LIST_SLICE(self->stack, x, len) < 0)  
  3184.         goto finally;
  3185.  
  3186.     res = 0;
  3187.  
  3188. finally:
  3189.  
  3190.     return res;
  3191. }
  3192.  
  3193.  
  3194. static int
  3195. load_setitem(Unpicklerobject *self) {
  3196.     return do_setitems(self, PyList_Size(self->stack) - 2);
  3197. }
  3198.  
  3199.  
  3200. static int
  3201. load_setitems(Unpicklerobject *self) {
  3202.     return do_setitems(self, marker(self));
  3203. }
  3204.  
  3205.  
  3206. static int
  3207. load_build(Unpicklerobject *self) {
  3208.     PyObject *value = 0, *inst = 0, *instdict = 0, *d_key = 0, *d_value = 0, 
  3209.              *junk = 0, *__setstate__ = 0;
  3210.     int len, i, res = -1;
  3211.  
  3212.     if ((len = PyList_Size(self->stack)) < 0)
  3213.         goto finally;
  3214.  
  3215.     UNLESS(value = PyList_GetItem(self->stack, len - 1))
  3216.         goto finally; 
  3217.     Py_INCREF(value);
  3218.  
  3219.     if (DEL_LIST_SLICE(self->stack, len - 1, len) < 0)
  3220.         goto finally;
  3221.  
  3222.     UNLESS(inst = PyList_GetItem(self->stack, len - 2))
  3223.         goto finally;
  3224.  
  3225.     UNLESS(__setstate__ = PyObject_GetAttr(inst, __setstate___str)) {
  3226.         PyErr_Clear();
  3227.  
  3228.         UNLESS(instdict = PyObject_GetAttr(inst, __dict___str))
  3229.             goto finally;
  3230.  
  3231.         i = 0;
  3232.         while (PyDict_Next(value, &i, &d_key, &d_value)) {
  3233.             if (PyObject_SetItem(instdict, d_key, d_value) < 0)
  3234.                 goto finally;
  3235.         }
  3236.     }
  3237.     else {
  3238.         UNLESS(self->arg)
  3239.             UNLESS(self->arg = PyTuple_New(1))
  3240.                 goto finally;
  3241.  
  3242.         Py_INCREF(value);
  3243.         if (PyTuple_SetItem(self->arg, 0, value) < 0)
  3244.             goto finally;
  3245.  
  3246.         UNLESS(junk = PyObject_CallObject(__setstate__, self->arg))
  3247.             goto finally;
  3248.         Py_DECREF(junk);
  3249.     }
  3250.  
  3251.     res = 0;
  3252.  
  3253. finally:
  3254.   Py_XDECREF(value);
  3255.   Py_XDECREF(instdict);
  3256.   Py_XDECREF(__setstate__);
  3257.   
  3258.   return res;
  3259. }
  3260.  
  3261.  
  3262. static int
  3263. load_mark(Unpicklerobject *self) {
  3264.     int len;
  3265.  
  3266.     if ((len = PyList_Size(self->stack)) < 0)
  3267.         return -1;
  3268.  
  3269.     if (!self->marks_size) {
  3270.         self->marks_size = 20;
  3271.         UNLESS(self->marks = (int *)malloc(self->marks_size * sizeof(int))) {
  3272.             PyErr_NoMemory();
  3273.             return -1;
  3274.         } 
  3275.     }
  3276.     else if ((self->num_marks + 1) >= self->marks_size) {
  3277.         UNLESS(self->marks = (int *)realloc(self->marks,
  3278.             (self->marks_size + 20) * sizeof(int))) {
  3279.             PyErr_NoMemory();
  3280.             return -1;
  3281.         }
  3282.  
  3283.         self->marks_size += 20;
  3284.     }
  3285.  
  3286.     self->marks[self->num_marks++] = len;
  3287.  
  3288.     return 0;
  3289. }
  3290.  
  3291. static int
  3292. load_reduce(Unpicklerobject *self) {
  3293.     PyObject *callable = 0, *arg_tup = 0, *ob = 0;
  3294.     int len, res = -1;
  3295.  
  3296.     if ((len = PyList_Size(self->stack)) < 0)
  3297.         goto finally;
  3298.  
  3299.     UNLESS(arg_tup = PyList_GetItem(self->stack, len - 1))
  3300.         goto finally;
  3301.  
  3302.     UNLESS(callable = PyList_GetItem(self->stack, len - 2))
  3303.         goto finally;
  3304.  
  3305.     UNLESS(ob = Instance_New(callable, arg_tup))
  3306.         goto finally;
  3307.  
  3308.     if (PyList_Append(self->stack, ob) < 0)
  3309.         goto finally;
  3310.  
  3311.     if (DEL_LIST_SLICE(self->stack, len - 2, len) < 0)
  3312.         goto finally;
  3313.  
  3314.     res = 0;
  3315.  
  3316. finally:
  3317.     Py_XDECREF(ob);
  3318.  
  3319.     return res;
  3320. }
  3321.     
  3322. static PyObject *
  3323. load(Unpicklerobject *self) {
  3324.     PyObject *stack = 0, *err = 0, *val = 0;
  3325.     int len;
  3326.     char *s;
  3327.  
  3328.     UNLESS(stack = PyList_New(0))
  3329.         goto err;
  3330.  
  3331.     self->stack = stack;
  3332.     self->num_marks = 0;
  3333.  
  3334.     while (1) {
  3335.         if ((*self->read_func)(self, &s, 1) < 0)
  3336.             break;
  3337.  
  3338.         switch (s[0]) {
  3339.             case NONE:
  3340.                 if (load_none(self) < 0)
  3341.                     break;
  3342.                 continue;
  3343.  
  3344.             case BININT:
  3345.                  if (load_binint(self) < 0)
  3346.                      break;
  3347.                  continue;
  3348.  
  3349.             case BININT1:
  3350.                 if (load_binint1(self) < 0)
  3351.                     break;
  3352.                 continue;
  3353.  
  3354.             case BININT2:
  3355.                 if (load_binint2(self) < 0)
  3356.                     break;
  3357.                 continue;
  3358.  
  3359.             case INT:
  3360.                 if (load_int(self) < 0)
  3361.                     break;
  3362.                 continue;
  3363.  
  3364.             case LONG:
  3365.                 if (load_long(self) < 0)
  3366.                     break;
  3367.                 continue;
  3368.  
  3369.             case FLOAT:
  3370.                 if (load_float(self) < 0)
  3371.                     break;
  3372.                 continue;
  3373.  
  3374. #ifdef FORMAT_1_3
  3375.             case BINFLOAT:
  3376.                 if (load_binfloat(self) < 0)
  3377.                     break;
  3378.                 continue;
  3379. #endif
  3380.  
  3381.             case BINSTRING:
  3382.                 if (load_binstring(self) < 0)
  3383.                     break;
  3384.                 continue;
  3385.  
  3386.             case SHORT_BINSTRING:
  3387.                 if (load_short_binstring(self) < 0)
  3388.                     break;
  3389.                 continue;
  3390.  
  3391.             case STRING:
  3392.                 if (load_string(self) < 0)
  3393.                     break;
  3394.                 continue;
  3395.  
  3396.             case EMPTY_TUPLE:
  3397.                 if (load_empty_tuple(self) < 0)
  3398.                     break;
  3399.                 continue;
  3400.  
  3401.             case TUPLE:
  3402.                 if (load_tuple(self) < 0)
  3403.                     break;
  3404.                 continue;
  3405.  
  3406.             case EMPTY_LIST:
  3407.                 if (load_empty_list(self) < 0)
  3408.                     break;
  3409.                 continue;
  3410.  
  3411.             case LIST:
  3412.                 if (load_list(self) < 0)
  3413.                     break;
  3414.                 continue;
  3415.  
  3416.             case EMPTY_DICT:
  3417.                 if (load_empty_dict(self) < 0)
  3418.                     break;
  3419.                 continue;
  3420.  
  3421.             case DICT:
  3422.                 if (load_dict(self) < 0)
  3423.                     break;
  3424.                 continue;
  3425.  
  3426.             case OBJ:
  3427.                 if (load_obj(self) < 0)
  3428.                     break;
  3429.                 continue;
  3430.  
  3431.             case INST:
  3432.                 if (load_inst(self) < 0)
  3433.                     break;
  3434.                 continue;
  3435.  
  3436.             case GLOBAL:
  3437.                 if (load_global(self) < 0)
  3438.                     break;
  3439.                 continue;
  3440.  
  3441.             case APPEND:
  3442.                 if (load_append(self) < 0)
  3443.                     break;
  3444.                 continue;
  3445.  
  3446.             case APPENDS:
  3447.                 if (load_appends(self) < 0)
  3448.                     break;
  3449.                 continue;
  3450.    
  3451.             case BUILD:
  3452.                 if (load_build(self) < 0)
  3453.                     break;
  3454.                 continue;
  3455.   
  3456.             case DUP:
  3457.                 if (load_dup(self) < 0)
  3458.                     break;
  3459.                 continue;
  3460.  
  3461.             case BINGET:
  3462.                 if (load_binget(self) < 0)
  3463.                     break;
  3464.                 continue;
  3465.  
  3466.             case LONG_BINGET:
  3467.                 if (load_long_binget(self) < 0)
  3468.                     break;
  3469.                 continue;
  3470.          
  3471.             case GET:
  3472.                 if (load_get(self) < 0)
  3473.                     break;
  3474.                 continue;
  3475.  
  3476.             case MARK:
  3477.                 if (load_mark(self) < 0)
  3478.                     break;
  3479.                 continue;
  3480.  
  3481.             case BINPUT:
  3482.                 if (load_binput(self) < 0)
  3483.                     break;
  3484.                 continue;
  3485.  
  3486.             case LONG_BINPUT:
  3487.                 if (load_long_binput(self) < 0)
  3488.                     break;
  3489.                 continue;
  3490.          
  3491.             case PUT:
  3492.                 if (load_put(self) < 0)
  3493.                     break;
  3494.                 continue;
  3495.  
  3496.             case POP:
  3497.                 if (load_pop(self) < 0)
  3498.                     break;
  3499.                 continue;
  3500.  
  3501.             case POP_MARK:
  3502.                 if (load_pop_mark(self) < 0)
  3503.                     break;
  3504.                 continue;
  3505.  
  3506.             case SETITEM:
  3507.                 if (load_setitem(self) < 0)
  3508.                     break;
  3509.                 continue;
  3510.  
  3511.             case SETITEMS:
  3512.                 if (load_setitems(self) < 0)
  3513.                     break;
  3514.                 continue;
  3515.  
  3516.             case STOP:
  3517.                 break;
  3518.  
  3519.             case PERSID:
  3520.                 if (load_persid(self) < 0)
  3521.                     break;
  3522.                 continue;
  3523.  
  3524.             case BINPERSID:
  3525.                 if (load_binpersid(self) < 0)
  3526.                     break;
  3527.                 continue;
  3528.  
  3529.             case REDUCE:
  3530.                 if (load_reduce(self) < 0)
  3531.                     break;
  3532.                 continue;
  3533.  
  3534.             default: 
  3535.                 cPickle_ErrFormat(UnpicklingError, "invalid load key, '%s'.", 
  3536.                     "c", s[0]);
  3537.                 goto err;
  3538.         }
  3539.  
  3540.         break;
  3541.     }
  3542.  
  3543.     if ((err = PyErr_Occurred()) == PyExc_EOFError) {
  3544.         PyErr_SetNone(PyExc_EOFError);
  3545.         goto err;
  3546.     }    
  3547.  
  3548.     if (err) goto err;
  3549.  
  3550.     if ((len = PyList_Size(stack)) < 0) goto err;
  3551.  
  3552.     UNLESS(val = PyList_GetItem(stack, len - 1)) goto err;
  3553.     Py_INCREF(val);
  3554.  
  3555.     Py_DECREF(stack);
  3556.  
  3557.     self->stack=NULL;
  3558.     return val;
  3559.  
  3560. err:
  3561.     self->stack=NULL;
  3562.     Py_XDECREF(stack);
  3563.  
  3564.     return NULL;
  3565. }
  3566.     
  3567.  
  3568. /* No-load functions to support noload, which is used to
  3569.    find persistent references. */
  3570.  
  3571. static int
  3572. noload_obj(Unpicklerobject *self) {
  3573.     int i, len;
  3574.  
  3575.     if ((i = marker(self)) < 0) return -1;
  3576.     if ((len = PyList_Size(self->stack)) < 0) return -1;
  3577.     return DEL_LIST_SLICE(self->stack, i+1, len);
  3578. }
  3579.  
  3580.  
  3581. static int
  3582. noload_inst(Unpicklerobject *self) {
  3583.     int i, j;
  3584.     char *s;
  3585.  
  3586.     if ((i = marker(self)) < 0) return -1;
  3587.     if ((j = PyList_Size(self->stack)) < 0) return -1;
  3588.     if (DEL_LIST_SLICE(self->stack, i, j) < 0) return -1;
  3589.     if ((*self->readline_func)(self, &s) < 0) return -1;
  3590.     if ((*self->readline_func)(self, &s) < 0) return -1;
  3591.     return PyList_Append(self->stack, Py_None);
  3592. }
  3593.  
  3594. static int
  3595. noload_global(Unpicklerobject *self) {
  3596.     char *s;
  3597.  
  3598.     if ((*self->readline_func)(self, &s) < 0) return -1;
  3599.     if ((*self->readline_func)(self, &s) < 0) return -1;
  3600.     return PyList_Append(self->stack, Py_None);
  3601. }
  3602.  
  3603. static int
  3604. noload_reduce(Unpicklerobject *self) {
  3605.     int len;
  3606.  
  3607.     if ((len = PyList_Size(self->stack)) < 0) return -1;
  3608.     if (DEL_LIST_SLICE(self->stack, len - 2, len) < 0) return -1;
  3609.     return PyList_Append(self->stack, Py_None);
  3610. }
  3611.  
  3612. static int
  3613. noload_build(Unpicklerobject *self) {
  3614.   int len;
  3615.  
  3616.   if ((len = PyList_Size(self->stack)) < 0) return -1;
  3617.   return DEL_LIST_SLICE(self->stack, len - 1, len);
  3618. }
  3619.  
  3620.  
  3621. static PyObject *
  3622. noload(Unpicklerobject *self) {
  3623.     PyObject *stack = 0, *err = 0, *val = 0;
  3624.     int len;
  3625.     char *s;
  3626.  
  3627.     UNLESS(stack = PyList_New(0))
  3628.         goto err;
  3629.  
  3630.     self->stack = stack;
  3631.     self->num_marks = 0;
  3632.  
  3633.     while (1) {
  3634.         if ((*self->read_func)(self, &s, 1) < 0)
  3635.             break;
  3636.  
  3637.         switch (s[0]) {
  3638.             case NONE:
  3639.                 if (load_none(self) < 0)
  3640.                     break;
  3641.                 continue;
  3642.  
  3643.             case BININT:
  3644.                  if (load_binint(self) < 0)
  3645.                      break;
  3646.                  continue;
  3647.  
  3648.             case BININT1:
  3649.                 if (load_binint1(self) < 0)
  3650.                     break;
  3651.                 continue;
  3652.  
  3653.             case BININT2:
  3654.                 if (load_binint2(self) < 0)
  3655.                     break;
  3656.                 continue;
  3657.  
  3658.             case INT:
  3659.                 if (load_int(self) < 0)
  3660.                     break;
  3661.                 continue;
  3662.  
  3663.             case LONG:
  3664.                 if (load_long(self) < 0)
  3665.                     break;
  3666.                 continue;
  3667.  
  3668.             case FLOAT:
  3669.                 if (load_float(self) < 0)
  3670.                     break;
  3671.                 continue;
  3672.  
  3673.             case BINFLOAT:
  3674.                 if (load_binfloat(self) < 0)
  3675.                     break;
  3676.                 continue;
  3677.  
  3678.             case BINSTRING:
  3679.                 if (load_binstring(self) < 0)
  3680.                     break;
  3681.                 continue;
  3682.  
  3683.             case SHORT_BINSTRING:
  3684.                 if (load_short_binstring(self) < 0)
  3685.                     break;
  3686.                 continue;
  3687.  
  3688.             case STRING:
  3689.                 if (load_string(self) < 0)
  3690.                     break;
  3691.                 continue;
  3692.  
  3693.             case EMPTY_TUPLE:
  3694.                 if (load_empty_tuple(self) < 0)
  3695.                     break;
  3696.                 continue;
  3697.  
  3698.             case TUPLE:
  3699.                 if (load_tuple(self) < 0)
  3700.                     break;
  3701.                 continue;
  3702.  
  3703.             case EMPTY_LIST:
  3704.                 if (load_empty_list(self) < 0)
  3705.                     break;
  3706.                 continue;
  3707.  
  3708.             case LIST:
  3709.                 if (load_list(self) < 0)
  3710.                     break;
  3711.                 continue;
  3712.  
  3713.             case EMPTY_DICT:
  3714.                 if (load_empty_dict(self) < 0)
  3715.                     break;
  3716.                 continue;
  3717.  
  3718.             case DICT:
  3719.                 if (load_dict(self) < 0)
  3720.                     break;
  3721.                 continue;
  3722.  
  3723.             case OBJ:
  3724.                 if (noload_obj(self) < 0)
  3725.                     break;
  3726.                 continue;
  3727.  
  3728.             case INST:
  3729.                 if (noload_inst(self) < 0)
  3730.                     break;
  3731.                 continue;
  3732.  
  3733.             case GLOBAL:
  3734.                 if (noload_global(self) < 0)
  3735.                     break;
  3736.                 continue;
  3737.  
  3738.             case APPEND:
  3739.                 if (load_append(self) < 0)
  3740.                     break;
  3741.                 continue;
  3742.  
  3743.             case APPENDS:
  3744.                 if (load_appends(self) < 0)
  3745.                     break;
  3746.                 continue;
  3747.    
  3748.             case BUILD:
  3749.                 if (noload_build(self) < 0)
  3750.                     break;
  3751.                 continue;
  3752.   
  3753.             case DUP:
  3754.                 if (load_dup(self) < 0)
  3755.                     break;
  3756.                 continue;
  3757.  
  3758.             case BINGET:
  3759.                 if (load_binget(self) < 0)
  3760.                     break;
  3761.                 continue;
  3762.  
  3763.             case LONG_BINGET:
  3764.                 if (load_long_binget(self) < 0)
  3765.                     break;
  3766.                 continue;
  3767.          
  3768.             case GET:
  3769.                 if (load_get(self) < 0)
  3770.                     break;
  3771.                 continue;
  3772.  
  3773.             case MARK:
  3774.                 if (load_mark(self) < 0)
  3775.                     break;
  3776.                 continue;
  3777.  
  3778.             case BINPUT:
  3779.                 if (load_binput(self) < 0)
  3780.                     break;
  3781.                 continue;
  3782.  
  3783.             case LONG_BINPUT:
  3784.                 if (load_long_binput(self) < 0)
  3785.                     break;
  3786.                 continue;
  3787.          
  3788.             case PUT:
  3789.                 if (load_put(self) < 0)
  3790.                     break;
  3791.                 continue;
  3792.  
  3793.             case POP:
  3794.                 if (load_pop(self) < 0)
  3795.                     break;
  3796.                 continue;
  3797.  
  3798.             case POP_MARK:
  3799.                 if (load_pop_mark(self) < 0)
  3800.                     break;
  3801.                 continue;
  3802.  
  3803.             case SETITEM:
  3804.                 if (load_setitem(self) < 0)
  3805.                     break;
  3806.                 continue;
  3807.  
  3808.             case SETITEMS:
  3809.                 if (load_setitems(self) < 0)
  3810.                     break;
  3811.                 continue;
  3812.  
  3813.             case STOP:
  3814.                 break;
  3815.  
  3816.             case PERSID:
  3817.                 if (load_persid(self) < 0)
  3818.                     break;
  3819.                 continue;
  3820.  
  3821.             case BINPERSID:
  3822.                 if (load_binpersid(self) < 0)
  3823.                     break;
  3824.                 continue;
  3825.  
  3826.             case REDUCE:
  3827.                 if (noload_reduce(self) < 0)
  3828.                     break;
  3829.                 continue;
  3830.  
  3831.             default: 
  3832.                 cPickle_ErrFormat(UnpicklingError, "invalid load key, '%s'.", 
  3833.                     "c", s[0]);
  3834.                 goto err;
  3835.         }
  3836.  
  3837.         break;
  3838.     }
  3839.  
  3840.     if ((err = PyErr_Occurred()) == PyExc_EOFError) {
  3841.         PyErr_SetNone(PyExc_EOFError);
  3842.         goto err;
  3843.     }    
  3844.  
  3845.     if (err) goto err;
  3846.  
  3847.     if ((len = PyList_Size(stack)) < 0) goto err;
  3848.  
  3849.     UNLESS(val = PyList_GetItem(stack, len - 1)) goto err;
  3850.     Py_INCREF(val);
  3851.  
  3852.     Py_DECREF(stack);
  3853.  
  3854.     self->stack=NULL;
  3855.     return val;
  3856.  
  3857. err:
  3858.     self->stack=NULL;
  3859.     Py_XDECREF(stack);
  3860.  
  3861.     return NULL;
  3862. }
  3863.     
  3864.  
  3865. static PyObject *
  3866. Unpickler_load(Unpicklerobject *self, PyObject *args) {
  3867.     UNLESS(PyArg_ParseTuple(args, "")) 
  3868.         return NULL;
  3869.  
  3870.     return load(self);
  3871. }
  3872.  
  3873. static PyObject *
  3874. Unpickler_noload(Unpicklerobject *self, PyObject *args) {
  3875.     UNLESS(PyArg_ParseTuple(args, "")) 
  3876.         return NULL;
  3877.  
  3878.     return noload(self);
  3879. }
  3880.  
  3881.  
  3882. static struct PyMethodDef Unpickler_methods[] = {
  3883.   {"load",         (PyCFunction)Unpickler_load,   1,
  3884.    "load() -- Load a pickle"
  3885.   },
  3886.   {"noload",         (PyCFunction)Unpickler_noload,   1,
  3887.    "noload() -- not load a pickle, but go through most of the motions\n"
  3888.    "\n"
  3889.    "This function can be used to read past a pickle without instantiating\n"
  3890.    "any objects or importing any modules.  It can also be used to find all\n"
  3891.    "persistent references without instantiating any objects or importing\n"
  3892.    "any modules.\n"
  3893.   },
  3894.   {NULL,              NULL}           /* sentinel */
  3895. };
  3896.  
  3897.  
  3898. static Unpicklerobject *
  3899. newUnpicklerobject(PyObject *f) {
  3900.     Unpicklerobject *self;
  3901.  
  3902.     UNLESS(self = PyObject_NEW(Unpicklerobject, &Unpicklertype))
  3903.         return NULL;
  3904.  
  3905.     self->file = NULL;
  3906.     self->arg = NULL;
  3907.     self->stack = NULL;
  3908.     self->pers_func = NULL;
  3909.     self->last_string = NULL;
  3910.     self->marks = NULL;
  3911.     self->num_marks = 0;
  3912.     self->marks_size = 0;
  3913.     self->buf_size = 0;
  3914.     self->read = NULL;
  3915.     self->readline = NULL;
  3916.     self->class_map = NULL;
  3917.  
  3918.     UNLESS(self->memo = PyDict_New()) {
  3919.        Py_XDECREF((PyObject *)self);
  3920.        return NULL;
  3921.     }
  3922.  
  3923.     Py_INCREF(f);
  3924.     self->file = f;
  3925.  
  3926.     /* Set read, readline based on type of f */
  3927.     if (PyFile_Check(f)) {
  3928.         self->fp = PyFile_AsFile(f);
  3929.         self->read_func = read_file;
  3930.         self->readline_func = readline_file;
  3931.     }
  3932.     else if (PycStringIO_InputCheck(f)) {
  3933.         self->fp = NULL;
  3934.         self->read_func = read_cStringIO;
  3935.         self->readline_func = readline_cStringIO;
  3936.     }
  3937.     else {
  3938.  
  3939.         self->fp = NULL;
  3940.         self->read_func = read_other;
  3941.         self->readline_func = readline_other;
  3942.  
  3943.         UNLESS((self->readline = PyObject_GetAttr(f, readline_str)) &&
  3944.             (self->read = PyObject_GetAttr(f, read_str))) {
  3945.             PyErr_Clear();
  3946.             PyErr_SetString( PyExc_TypeError, "argument must have 'read' and "
  3947.                 "'readline' attributes" );
  3948.         goto err;
  3949.         }
  3950.     }
  3951.  
  3952.     if(PyEval_GetRestricted()) {
  3953.     /* Restricted execution, get private tables */
  3954.     PyObject *m;
  3955.  
  3956.     UNLESS(self->class_map=PyDict_New()) goto err;
  3957.     UNLESS(m=PyImport_Import(copy_reg_str)) goto err;
  3958.     self->safe_constructors=PyObject_GetAttr(m, safe_constructors_str);
  3959.     Py_DECREF(m);
  3960.     UNLESS(self->safe_constructors) goto err;
  3961.     }
  3962.     else {
  3963.     self->class_map=class_map;
  3964.     Py_INCREF(class_map);
  3965.     self->safe_constructors=safe_constructors;
  3966.     Py_INCREF(safe_constructors);
  3967.     }
  3968.  
  3969.     return self;
  3970.  
  3971. err:
  3972.     Py_DECREF((PyObject *)self);
  3973.     return NULL;
  3974. }
  3975.  
  3976.  
  3977. static PyObject *
  3978. get_Unpickler(PyObject *self, PyObject *args) {
  3979.     PyObject *file;
  3980.   
  3981.     UNLESS(PyArg_ParseTuple(args, "O", &file))
  3982.         return NULL;
  3983.     return (PyObject *)newUnpicklerobject(file);
  3984. }
  3985.  
  3986.  
  3987. static void
  3988. Unpickler_dealloc(Unpicklerobject *self) {
  3989.     Py_XDECREF(self->readline);
  3990.     Py_XDECREF(self->read);
  3991.     Py_XDECREF(self->file);
  3992.     Py_XDECREF(self->memo);
  3993.     Py_XDECREF(self->stack);
  3994.     Py_XDECREF(self->pers_func);
  3995.     Py_XDECREF(self->arg);
  3996.     Py_XDECREF(self->last_string);
  3997.     Py_XDECREF(self->class_map);
  3998.     Py_XDECREF(self->safe_constructors);
  3999.  
  4000.     if (self->marks) {
  4001.         free(self->marks);
  4002.     }
  4003.  
  4004.     if (self->buf_size) {
  4005.         free(self->buf);
  4006.     }
  4007.     
  4008.     PyMem_DEL(self);
  4009. }
  4010.  
  4011.  
  4012. static PyObject *
  4013. Unpickler_getattr(Unpicklerobject *self, char *name) {
  4014.     if (!strcmp(name, "persistent_load")) {
  4015.         if (!self->pers_func) {
  4016.             PyErr_SetString(PyExc_AttributeError, name);
  4017.             return NULL;
  4018.         }
  4019.  
  4020.         Py_INCREF(self->pers_func);
  4021.         return self->pers_func;
  4022.     }
  4023.  
  4024.     if (!strcmp(name, "memo")) {
  4025.         if (!self->memo) {
  4026.             PyErr_SetString(PyExc_AttributeError, name);
  4027.             return NULL;
  4028.         }
  4029.  
  4030.         Py_INCREF(self->memo);
  4031.         return self->memo;
  4032.     }
  4033.  
  4034.     if (!strcmp(name, "stack")) {
  4035.         if (!self->stack) {
  4036.             PyErr_SetString(PyExc_AttributeError, name);
  4037.             return NULL;
  4038.         }
  4039.  
  4040.         Py_INCREF(self->stack);
  4041.         return self->stack;
  4042.     }
  4043.  
  4044.     if (!strcmp(name, "UnpicklingError")) {
  4045.         Py_INCREF(UnpicklingError);
  4046.         return UnpicklingError;
  4047.     }
  4048.  
  4049.     return Py_FindMethod(Unpickler_methods, (PyObject *)self, name);
  4050. }
  4051.  
  4052.  
  4053. static int
  4054. Unpickler_setattr(Unpicklerobject *self, char *name, PyObject *value) {
  4055.     if (!strcmp(name, "persistent_load")) {
  4056.         Py_XDECREF(self->pers_func);
  4057.         self->pers_func = value;
  4058.         Py_INCREF(value);
  4059.         return 0;
  4060.     }
  4061.  
  4062.     PyErr_SetString(PyExc_AttributeError, name);
  4063.     return -1;
  4064. }
  4065.  
  4066.  
  4067. static PyObject *
  4068. cpm_dump(PyObject *self, PyObject *args) {
  4069.     PyObject *ob, *file, *res = NULL;
  4070.     Picklerobject *pickler = 0;
  4071.     int bin = 0;
  4072.  
  4073.     UNLESS(PyArg_ParseTuple(args, "OO|i", &ob, &file, &bin))
  4074.         goto finally;
  4075.  
  4076.     UNLESS(pickler = newPicklerobject(file, bin))
  4077.         goto finally;
  4078.  
  4079.     if (dump(pickler, ob) < 0)
  4080.         goto finally;
  4081.  
  4082.     Py_INCREF(Py_None);
  4083.     res = Py_None;
  4084.  
  4085. finally:
  4086.     Py_XDECREF(pickler);
  4087.  
  4088.     return res;
  4089. }
  4090.  
  4091.  
  4092. static PyObject *
  4093. cpm_dumps(PyObject *self, PyObject *args) {
  4094.     PyObject *ob, *file = 0, *res = NULL;
  4095.     Picklerobject *pickler = 0;
  4096.     int bin = 0;
  4097.  
  4098.     UNLESS(PyArg_ParseTuple(args, "O|i", &ob, &bin))
  4099.         goto finally;
  4100.  
  4101.     UNLESS(file = PycStringIO->NewOutput(128))
  4102.         goto finally;
  4103.  
  4104.     UNLESS(pickler = newPicklerobject(file, bin))
  4105.         goto finally;
  4106.  
  4107.     if (dump(pickler, ob) < 0)
  4108.         goto finally;
  4109.  
  4110.     res = PycStringIO->cgetvalue(file);
  4111.  
  4112. finally:
  4113.     Py_XDECREF(pickler);
  4114.     Py_XDECREF(file);
  4115.  
  4116.     return res;
  4117. }  
  4118.   
  4119.  
  4120. static PyObject *
  4121. cpm_load(PyObject *self, PyObject *args) {
  4122.     Unpicklerobject *unpickler = 0;
  4123.     PyObject *ob, *res = NULL;
  4124.  
  4125.     UNLESS(PyArg_ParseTuple(args, "O", &ob))
  4126.         goto finally;
  4127.  
  4128.     UNLESS(unpickler = newUnpicklerobject(ob))
  4129.         goto finally;
  4130.  
  4131.     res = load(unpickler);
  4132.  
  4133. finally:
  4134.     Py_XDECREF(unpickler);
  4135.  
  4136.     return res;
  4137. }
  4138.  
  4139.  
  4140. static PyObject *
  4141. cpm_loads(PyObject *self, PyObject *args) {
  4142.     PyObject *ob, *file = 0, *res = NULL;
  4143.     Unpicklerobject *unpickler = 0;
  4144.  
  4145.     UNLESS(PyArg_ParseTuple(args, "O", &ob))
  4146.         goto finally;
  4147.  
  4148.     UNLESS(file = PycStringIO->NewInput(ob))
  4149.         goto finally;
  4150.   
  4151.     UNLESS(unpickler = newUnpicklerobject(file))
  4152.         goto finally;
  4153.  
  4154.     res = load(unpickler);
  4155.  
  4156. finally:
  4157.     Py_XDECREF(file);
  4158.     Py_XDECREF(unpickler);
  4159.  
  4160.     return res;
  4161. }
  4162.  
  4163.  
  4164. static char Unpicklertype__doc__[] = 
  4165. "Objects that know how to unpickle";
  4166.  
  4167. static PyTypeObject Unpicklertype = {
  4168.     PyObject_HEAD_INIT(NULL)
  4169.     0,                            /*ob_size*/
  4170.     "Unpickler",                  /*tp_name*/
  4171.     sizeof(Unpicklerobject),              /*tp_basicsize*/
  4172.     0,                            /*tp_itemsize*/
  4173.     /* methods */
  4174.     (destructor)Unpickler_dealloc,        /*tp_dealloc*/
  4175.     (printfunc)0,         /*tp_print*/
  4176.     (getattrfunc)Unpickler_getattr,       /*tp_getattr*/
  4177.     (setattrfunc)Unpickler_setattr,       /*tp_setattr*/
  4178.     (cmpfunc)0,           /*tp_compare*/
  4179.     (reprfunc)0,          /*tp_repr*/
  4180.     0,                    /*tp_as_number*/
  4181.     0,            /*tp_as_sequence*/
  4182.     0,            /*tp_as_mapping*/
  4183.     (hashfunc)0,          /*tp_hash*/
  4184.     (ternaryfunc)0,               /*tp_call*/
  4185.     (reprfunc)0,          /*tp_str*/
  4186.  
  4187.     /* Space for future expansion */
  4188.     0L,0L,0L,0L,
  4189.     Unpicklertype__doc__ /* Documentation string */
  4190. };
  4191.  
  4192. static struct PyMethodDef cPickle_methods[] = {
  4193.   {"dump",         (PyCFunction)cpm_dump,         1,
  4194.    "dump(object, file, [binary]) --"
  4195.    "Write an object in pickle format to the given file\n"
  4196.    "\n"
  4197.    "If the optional argument, binary, is provided and is true, then the\n"
  4198.    "pickle will be written in binary format, which is more space and\n"
  4199.    "computationally efficient. \n"
  4200.   },
  4201.   {"dumps",        (PyCFunction)cpm_dumps,        1,
  4202.    "dumps(object, [binary]) --"
  4203.    "Return a string containing an object in pickle format\n"
  4204.    "\n"
  4205.    "If the optional argument, binary, is provided and is true, then the\n"
  4206.    "pickle will be written in binary format, which is more space and\n"
  4207.    "computationally efficient. \n"
  4208.   },
  4209.   {"load",         (PyCFunction)cpm_load,         1,
  4210.    "load(file) -- Load a pickle from the given file"},
  4211.   {"loads",        (PyCFunction)cpm_loads,        1,
  4212.    "loads(string) -- Load a pickle from the given string"},
  4213.   {"Pickler",      (PyCFunction)get_Pickler,      1,
  4214.    "Pickler(file, [binary]) -- Create a pickler\n"
  4215.    "\n"
  4216.    "If the optional argument, binary, is provided and is true, then\n"
  4217.    "pickles will be written in binary format, which is more space and\n"
  4218.    "computationally efficient. \n"
  4219.   },
  4220.   {"Unpickler",    (PyCFunction)get_Unpickler,    1,
  4221.    "Unpickler(file) -- Create an unpickler"},
  4222.   { NULL, NULL }
  4223. };
  4224.  
  4225.  
  4226. #define CHECK_FOR_ERRORS(MESS) \
  4227. if(PyErr_Occurred()) { \
  4228.     PyObject *__sys_exc_type, *__sys_exc_value, *__sys_exc_traceback; \
  4229.     PyErr_Fetch( &__sys_exc_type, &__sys_exc_value, &__sys_exc_traceback); \
  4230.     fprintf(stderr, # MESS ":\n\t"); \
  4231.     PyObject_Print(__sys_exc_type, stderr,0); \
  4232.     fprintf(stderr,", "); \
  4233.     PyObject_Print(__sys_exc_value, stderr,0); \
  4234.     fprintf(stderr,"\n"); \
  4235.     fflush(stderr); \
  4236.     Py_FatalError(# MESS); \
  4237. }
  4238.  
  4239.  
  4240. static int
  4241. init_stuff(PyObject *module, PyObject *module_dict) {
  4242.     PyObject *string, *copy_reg;
  4243.  
  4244. #define INIT_STR(S) UNLESS(S ## _str=PyString_FromString(#S)) return -1;
  4245.  
  4246.     INIT_STR(__class__);
  4247.     INIT_STR(__getinitargs__);
  4248.     INIT_STR(__dict__);
  4249.     INIT_STR(__getstate__);
  4250.     INIT_STR(__setstate__);
  4251.     INIT_STR(__name__);
  4252.     INIT_STR(__main__);
  4253.     INIT_STR(__reduce__);
  4254.     INIT_STR(write);
  4255.     INIT_STR(__safe_for_unpickling__);
  4256.     INIT_STR(append);
  4257.     INIT_STR(read);
  4258.     INIT_STR(readline);
  4259.     INIT_STR(copy_reg);
  4260.     INIT_STR(dispatch_table);
  4261.     INIT_STR(safe_constructors);
  4262.     INIT_STR(__basicnew__);
  4263.  
  4264.     UNLESS(copy_reg = PyImport_ImportModule("copy_reg"))
  4265.         return -1;
  4266.  
  4267.     /* These next few are special because we want to use different
  4268.        ones in restricted mode. */
  4269.  
  4270.     UNLESS(dispatch_table = PyObject_GetAttr(copy_reg, dispatch_table_str))
  4271.         return -1;
  4272.  
  4273.     UNLESS(safe_constructors = PyObject_GetAttr(copy_reg,
  4274.                         safe_constructors_str))
  4275.         return -1;
  4276.  
  4277.     Py_DECREF(copy_reg);
  4278.  
  4279.     UNLESS(class_map = PyDict_New()) return -1;
  4280.  
  4281.     /* Down to here ********************************** */
  4282.  
  4283.     UNLESS(string = PyImport_ImportModule("string"))
  4284.         return -1;
  4285.  
  4286.     UNLESS(atol_func = PyObject_GetAttrString(string, "atol"))
  4287.         return -1;
  4288.  
  4289.     Py_DECREF(string);
  4290.  
  4291.     UNLESS(empty_tuple = PyTuple_New(0))
  4292.         return -1;
  4293.  
  4294.     UNLESS(PicklingError = PyString_FromString("cPickle.PicklingError"))
  4295.         return -1;
  4296.  
  4297.     if (PyDict_SetItemString(module_dict, "PicklingError", 
  4298.         PicklingError) < 0)
  4299.         return -1;
  4300.  
  4301.     UNLESS(UnpicklingError = PyString_FromString("cPickle.UnpicklingError"))
  4302.         return -1;
  4303.  
  4304.     if (PyDict_SetItemString(module_dict, "UnpicklingError",
  4305.         UnpicklingError) < 0)
  4306.         return -1;
  4307.  
  4308.     PycString_IMPORT;
  4309.  
  4310.     return 0;
  4311. }
  4312.  
  4313. void
  4314. initcPickle Py_PROTO((void)) {
  4315.     PyObject *m, *d, *v;
  4316.     char *rev="1.48";
  4317.     PyObject *format_version;
  4318.     PyObject *compatible_formats;
  4319.  
  4320.     Picklertype.ob_type = &PyType_Type;
  4321.     Unpicklertype.ob_type = &PyType_Type;
  4322.  
  4323.     /* Create the module and add the functions */
  4324.     m = Py_InitModule4("cPickle", cPickle_methods,
  4325.                      cPickle_module_documentation,
  4326.                      (PyObject*)NULL,PYTHON_API_VERSION);
  4327.  
  4328.     /* Add some symbolic constants to the module */
  4329.     d = PyModule_GetDict(m);
  4330.     PyDict_SetItemString(d,"__version__", v = PyString_FromString(rev));
  4331.     Py_XDECREF(v);
  4332.  
  4333. #ifdef FORMAT_1_3
  4334.     format_version = PyString_FromString("1.3");
  4335.     compatible_formats = Py_BuildValue("[sss]", "1.0", "1.1", "1.2");
  4336. #else
  4337.     format_version = PyString_FromString("1.2");
  4338.     compatible_formats = Py_BuildValue("[ss]", "1.0", "1.1");
  4339. #endif
  4340.  
  4341.     PyDict_SetItemString(d, "format_version", format_version);
  4342.     PyDict_SetItemString(d, "compatible_formats", compatible_formats);
  4343.     Py_XDECREF(format_version);
  4344.     Py_XDECREF(compatible_formats);
  4345.  
  4346.     init_stuff(m, d);
  4347.     CHECK_FOR_ERRORS("can't initialize module cPickle");
  4348. }
  4349.